mirror of
https://github.com/gui-cs/Terminal.Gui.git
synced 2025-12-27 00:07:58 +01:00
42b9ad1d61
* initial commit * Clarified RootMouseEvent * Added application mouse coord tests * ViewToScreen -> BoundsToScreen * Simplified View.Move * Simplified View.Move * Updated API docs; made some functions private * more ViewLayout cleanup * more ViewLayout cleanup * Added View.ScreenToBounds and low-level coord unit tests * Partial fix * Refactored Application.OnMouseEvent... Tests still fail and views are broken * Added Bounds/FrameToScreen * Remamed ScreenToView->ScreenToFrame * All unit tests pass * Fixed ListView * Fixed TableView * Fixed ColorPicker * Fixed RadioGroup * Fixed ListView unit tests * Fixed line drawing scenario * Updated comment * fixed api doc typo * fixed formatting * added some thickness Contains unit tests * MouseEvent api doc updates * More thickness tests * More thickness tests
983 lines
27 KiB
C#
983 lines
27 KiB
C#
using System;
|
|
using System.Diagnostics;
|
|
using System.Linq;
|
|
using System.Runtime.InteropServices;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using Xunit;
|
|
using Xunit.Abstractions;
|
|
|
|
// Alias Console to MockConsole so we don't accidentally use Console
|
|
using Console = Terminal.Gui.FakeConsole;
|
|
|
|
namespace Terminal.Gui.ApplicationTests;
|
|
|
|
public class ApplicationTests {
|
|
readonly ITestOutputHelper output;
|
|
|
|
public ApplicationTests (ITestOutputHelper output)
|
|
{
|
|
this.output = output;
|
|
#if DEBUG_IDISPOSABLE
|
|
Responder.Instances.Clear ();
|
|
RunState.Instances.Clear ();
|
|
#endif
|
|
}
|
|
|
|
void Pre_Init_State ()
|
|
{
|
|
Assert.Null (Application.Driver);
|
|
Assert.Null (Application.Top);
|
|
Assert.Null (Application.Current);
|
|
Assert.Null (Application.MainLoop);
|
|
}
|
|
|
|
void Post_Init_State ()
|
|
{
|
|
Assert.NotNull (Application.Driver);
|
|
Assert.NotNull (Application.Top);
|
|
Assert.NotNull (Application.Current);
|
|
Assert.NotNull (Application.MainLoop);
|
|
// FakeDriver is always 80x25
|
|
Assert.Equal (80, Application.Driver.Cols);
|
|
Assert.Equal (25, Application.Driver.Rows);
|
|
|
|
}
|
|
|
|
void Init ()
|
|
{
|
|
Application.Init (new FakeDriver ());
|
|
Assert.NotNull (Application.Driver);
|
|
Assert.NotNull (Application.MainLoop);
|
|
Assert.NotNull (SynchronizationContext.Current);
|
|
}
|
|
|
|
void Shutdown ()
|
|
{
|
|
Application.Shutdown ();
|
|
}
|
|
|
|
[Fact]
|
|
public void Init_Shutdown_Cleans_Up ()
|
|
{
|
|
// Verify initial state is per spec
|
|
//Pre_Init_State ();
|
|
|
|
Application.Init (new FakeDriver ());
|
|
|
|
// Verify post-Init state is correct
|
|
//Post_Init_State ();
|
|
|
|
Application.Shutdown ();
|
|
|
|
// Verify state is back to initial
|
|
//Pre_Init_State ();
|
|
#if DEBUG_IDISPOSABLE
|
|
// Validate there are no outstanding Responder-based instances
|
|
// after a scenario was selected to run. This proves the main UI Catalog
|
|
// 'app' closed cleanly.
|
|
Assert.Empty (Responder.Instances);
|
|
#endif
|
|
}
|
|
|
|
[Fact]
|
|
public void Init_Unbalanced_Throws ()
|
|
{
|
|
Application.Init (new FakeDriver ());
|
|
|
|
Toplevel topLevel = null;
|
|
Assert.Throws<InvalidOperationException> (() => Application.InternalInit (() => topLevel = new TestToplevel (), new FakeDriver ()));
|
|
Shutdown ();
|
|
|
|
Assert.Null (Application.Top);
|
|
Assert.Null (Application.MainLoop);
|
|
Assert.Null (Application.Driver);
|
|
|
|
// Now try the other way
|
|
topLevel = null;
|
|
Application.InternalInit (() => topLevel = new TestToplevel (), new FakeDriver ());
|
|
|
|
Assert.Throws<InvalidOperationException> (() => Application.Init (new FakeDriver ()));
|
|
Shutdown ();
|
|
|
|
Assert.Null (Application.Top);
|
|
Assert.Null (Application.MainLoop);
|
|
Assert.Null (Application.Driver);
|
|
}
|
|
|
|
class TestToplevel : Toplevel {
|
|
public TestToplevel ()
|
|
{
|
|
IsOverlappedContainer = false;
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void Init_Null_Driver_Should_Pick_A_Driver ()
|
|
{
|
|
Application.Init (null);
|
|
|
|
Assert.NotNull (Application.Driver);
|
|
|
|
Shutdown ();
|
|
}
|
|
|
|
[Fact]
|
|
public void Init_Begin_End_Cleans_Up ()
|
|
{
|
|
Init ();
|
|
|
|
// Begin will cause Run() to be called, which will call Begin(). Thus will block the tests
|
|
// if we don't stop
|
|
Application.Iteration += (s, a) => {
|
|
Application.RequestStop ();
|
|
};
|
|
|
|
RunState runstate = null;
|
|
EventHandler<RunStateEventArgs> NewRunStateFn = (s, e) => {
|
|
Assert.NotNull (e.State);
|
|
runstate = e.State;
|
|
};
|
|
Application.NotifyNewRunState += NewRunStateFn;
|
|
|
|
Toplevel topLevel = new Toplevel ();
|
|
var rs = Application.Begin (topLevel);
|
|
Assert.NotNull (rs);
|
|
Assert.NotNull (runstate);
|
|
Assert.Equal (rs, runstate);
|
|
|
|
Assert.Equal (topLevel, Application.Top);
|
|
Assert.Equal (topLevel, Application.Current);
|
|
|
|
Application.NotifyNewRunState -= NewRunStateFn;
|
|
Application.End (runstate);
|
|
|
|
Assert.Null (Application.Current);
|
|
Assert.NotNull (Application.Top);
|
|
Assert.NotNull (Application.MainLoop);
|
|
Assert.NotNull (Application.Driver);
|
|
|
|
Shutdown ();
|
|
|
|
Assert.Null (Application.Top);
|
|
Assert.Null (Application.MainLoop);
|
|
Assert.Null (Application.Driver);
|
|
}
|
|
|
|
[Fact]
|
|
public void InitWithTopLevelFactory_Begin_End_Cleans_Up ()
|
|
{
|
|
// Begin will cause Run() to be called, which will call Begin(). Thus will block the tests
|
|
// if we don't stop
|
|
Application.Iteration += (s, a) => {
|
|
Application.RequestStop ();
|
|
};
|
|
|
|
// NOTE: Run<T>, when called after Init has been called behaves differently than
|
|
// when called if Init has not been called.
|
|
Toplevel topLevel = null;
|
|
Application.InternalInit (() => topLevel = new TestToplevel (), new FakeDriver ());
|
|
|
|
RunState runstate = null;
|
|
EventHandler<RunStateEventArgs> NewRunStateFn = (s, e) => {
|
|
Assert.NotNull (e.State);
|
|
runstate = e.State;
|
|
};
|
|
Application.NotifyNewRunState += NewRunStateFn;
|
|
|
|
var rs = Application.Begin (topLevel);
|
|
Assert.NotNull (rs);
|
|
Assert.NotNull (runstate);
|
|
Assert.Equal (rs, runstate);
|
|
|
|
Assert.Equal (topLevel, Application.Top);
|
|
Assert.Equal (topLevel, Application.Current);
|
|
|
|
Application.NotifyNewRunState -= NewRunStateFn;
|
|
Application.End (runstate);
|
|
|
|
Assert.Null (Application.Current);
|
|
Assert.NotNull (Application.Top);
|
|
Assert.NotNull (Application.MainLoop);
|
|
Assert.NotNull (Application.Driver);
|
|
|
|
Shutdown ();
|
|
|
|
Assert.Null (Application.Top);
|
|
Assert.Null (Application.MainLoop);
|
|
Assert.Null (Application.Driver);
|
|
}
|
|
|
|
[Fact]
|
|
public void Begin_Null_Toplevel_Throws ()
|
|
{
|
|
// Setup Mock driver
|
|
Init ();
|
|
|
|
// Test null Toplevel
|
|
Assert.Throws<ArgumentNullException> (() => Application.Begin (null));
|
|
|
|
Shutdown ();
|
|
|
|
Assert.Null (Application.Top);
|
|
Assert.Null (Application.MainLoop);
|
|
Assert.Null (Application.Driver);
|
|
}
|
|
|
|
#region RunTests
|
|
|
|
[Fact]
|
|
public void Run_T_After_InitWithDriver_with_TopLevel_Throws ()
|
|
{
|
|
// Setup Mock driver
|
|
Init ();
|
|
|
|
// Run<Toplevel> when already initialized with a Driver will throw (because Toplevel is not dervied from TopLevel)
|
|
Assert.Throws<ArgumentException> (() => Application.Run<Toplevel> (errorHandler: null));
|
|
|
|
Shutdown ();
|
|
|
|
Assert.Null (Application.Top);
|
|
Assert.Null (Application.MainLoop);
|
|
Assert.Null (Application.Driver);
|
|
}
|
|
|
|
[Fact]
|
|
public void Run_T_After_InitWithDriver_with_TopLevel_and_Driver_Throws ()
|
|
{
|
|
// Setup Mock driver
|
|
Init ();
|
|
|
|
// Run<Toplevel> when already initialized with a Driver will throw (because Toplevel is not dervied from TopLevel)
|
|
Assert.Throws<ArgumentException> (() => Application.Run<Toplevel> (errorHandler: null, new FakeDriver ()));
|
|
|
|
Shutdown ();
|
|
|
|
Assert.Null (Application.Top);
|
|
Assert.Null (Application.MainLoop);
|
|
Assert.Null (Application.Driver);
|
|
}
|
|
|
|
[Fact]
|
|
public void Run_T_After_InitWithDriver_with_TestTopLevel_DoesNotThrow ()
|
|
{
|
|
// Setup Mock driver
|
|
Init ();
|
|
|
|
Application.Iteration += (s, a) => {
|
|
Application.RequestStop ();
|
|
};
|
|
|
|
// Init has been called and we're passing no driver to Run<TestTopLevel>. This is ok.
|
|
Application.Run<TestToplevel> ();
|
|
|
|
Shutdown ();
|
|
|
|
Assert.Null (Application.Top);
|
|
Assert.Null (Application.MainLoop);
|
|
Assert.Null (Application.Driver);
|
|
}
|
|
|
|
[Fact]
|
|
public void Run_T_After_InitNullDriver_with_TestTopLevel_Throws ()
|
|
{
|
|
Application._forceFakeConsole = true;
|
|
|
|
Application.Init (null);
|
|
Assert.Equal (typeof (FakeDriver), Application.Driver.GetType ());
|
|
|
|
Application.Iteration += (s, a) => {
|
|
Application.RequestStop ();
|
|
};
|
|
|
|
// Init has been called without selecting a driver and we're passing no driver to Run<TestTopLevel>. Bad
|
|
Application.Run<TestToplevel> ();
|
|
|
|
Shutdown ();
|
|
|
|
Assert.Null (Application.Top);
|
|
Assert.Null (Application.MainLoop);
|
|
Assert.Null (Application.Driver);
|
|
}
|
|
|
|
[Fact]
|
|
public void Run_T_Init_Driver_Cleared_with_TestTopLevel_Throws ()
|
|
{
|
|
Init ();
|
|
|
|
Application.Driver = null;
|
|
|
|
Application.Iteration += (s, a) => {
|
|
Application.RequestStop ();
|
|
};
|
|
|
|
// Init has been called, but Driver has been set to null. Bad.
|
|
Assert.Throws<InvalidOperationException> (() => Application.Run<TestToplevel> ());
|
|
|
|
Shutdown ();
|
|
|
|
Assert.Null (Application.Top);
|
|
Assert.Null (Application.MainLoop);
|
|
Assert.Null (Application.Driver);
|
|
}
|
|
|
|
[Fact]
|
|
public void Run_T_NoInit_DoesNotThrow ()
|
|
{
|
|
Application._forceFakeConsole = true;
|
|
|
|
Application.Iteration += (s, a) => {
|
|
Application.RequestStop ();
|
|
};
|
|
|
|
Application.Run<TestToplevel> ();
|
|
Assert.Equal (typeof (FakeDriver), Application.Driver.GetType ());
|
|
|
|
Shutdown ();
|
|
|
|
Assert.Null (Application.Top);
|
|
Assert.Null (Application.MainLoop);
|
|
Assert.Null (Application.Driver);
|
|
}
|
|
|
|
[Fact]
|
|
public void Run_T_NoInit_WithDriver_DoesNotThrow ()
|
|
{
|
|
Application.Iteration += (s, a) => {
|
|
Application.RequestStop ();
|
|
};
|
|
|
|
// Init has NOT been called and we're passing a valid driver to Run<TestTopLevel>. This is ok.
|
|
Application.Run<TestToplevel> (errorHandler: null, new FakeDriver ());
|
|
|
|
Shutdown ();
|
|
|
|
Assert.Null (Application.Top);
|
|
Assert.Null (Application.MainLoop);
|
|
Assert.Null (Application.Driver);
|
|
}
|
|
|
|
[Fact]
|
|
public void Run_RequestStop_Stops ()
|
|
{
|
|
// Setup Mock driver
|
|
Init ();
|
|
|
|
var top = new Toplevel ();
|
|
var rs = Application.Begin (top);
|
|
Assert.NotNull (rs);
|
|
Assert.Equal (top, Application.Current);
|
|
|
|
Application.Iteration += (s, a) => {
|
|
Application.RequestStop ();
|
|
};
|
|
|
|
Application.Run (top);
|
|
|
|
Application.Shutdown ();
|
|
Assert.Null (Application.Current);
|
|
Assert.Null (Application.Top);
|
|
Assert.Null (Application.MainLoop);
|
|
Assert.Null (Application.Driver);
|
|
}
|
|
|
|
[Fact]
|
|
public void Run_RunningFalse_Stops ()
|
|
{
|
|
// Setup Mock driver
|
|
Init ();
|
|
|
|
var top = new Toplevel ();
|
|
var rs = Application.Begin (top);
|
|
Assert.NotNull (rs);
|
|
Assert.Equal (top, Application.Current);
|
|
|
|
Application.Iteration += (s, a) => {
|
|
top.Running = false;
|
|
};
|
|
|
|
Application.Run (top);
|
|
|
|
Application.Shutdown ();
|
|
Assert.Null (Application.Current);
|
|
Assert.Null (Application.Top);
|
|
Assert.Null (Application.MainLoop);
|
|
Assert.Null (Application.Driver);
|
|
}
|
|
|
|
[Fact]
|
|
public void Run_Loaded_Ready_Unlodaded_Events ()
|
|
{
|
|
Init ();
|
|
var top = Application.Top;
|
|
var count = 0;
|
|
top.Loaded += (s, e) => count++;
|
|
top.Ready += (s, e) => count++;
|
|
top.Unloaded += (s, e) => count++;
|
|
Application.Iteration += (s, a) => Application.RequestStop ();
|
|
Application.Run ();
|
|
Application.Shutdown ();
|
|
Assert.Equal (3, count);
|
|
}
|
|
|
|
[Fact]
|
|
public void Run_Toplevel_With_Modal_View_Does_Not_Refresh_If_Not_Dirty ()
|
|
{
|
|
Init ();
|
|
var count = 0;
|
|
Dialog d = null;
|
|
var top = Application.Top;
|
|
top.DrawContent += (s, a) => count++;
|
|
var iteration = -1;
|
|
Application.Iteration += (s, a) => {
|
|
iteration++;
|
|
if (iteration == 0) {
|
|
d = new Dialog ();
|
|
d.DrawContent += (s, a) => count++;
|
|
Application.Run (d);
|
|
} else if (iteration < 3) {
|
|
Application.OnMouseEvent (new (new () { X = 0, Y = 0, Flags = MouseFlags.ReportMousePosition }));
|
|
Assert.False (top.NeedsDisplay);
|
|
Assert.False (top.SubViewNeedsDisplay);
|
|
Assert.False (top.LayoutNeeded);
|
|
Assert.False (d.NeedsDisplay);
|
|
Assert.False (d.SubViewNeedsDisplay);
|
|
Assert.False (d.LayoutNeeded);
|
|
} else {
|
|
Application.RequestStop ();
|
|
}
|
|
};
|
|
Application.Run ();
|
|
Application.Shutdown ();
|
|
// 1 - First top load, 1 - Dialog load, 1 - Dialog unload, Total - 3.
|
|
Assert.Equal (3, count);
|
|
}
|
|
|
|
[Fact]
|
|
public void Run_A_Modal_Toplevel_Refresh_Background_On_Moving ()
|
|
{
|
|
Init ();
|
|
var d = new Dialog () { Width = 5, Height = 5 };
|
|
((FakeDriver)Application.Driver).SetBufferSize (10, 10);
|
|
var rs = Application.Begin (d);
|
|
TestHelpers.AssertDriverContentsWithFrameAre (@"
|
|
┌───┐
|
|
│ │
|
|
│ │
|
|
│ │
|
|
└───┘", output);
|
|
|
|
var attributes = new Attribute [] {
|
|
// 0
|
|
new Attribute (ColorName.White, ColorName.Black),
|
|
// 1
|
|
Colors.Dialog.Normal
|
|
};
|
|
TestHelpers.AssertDriverColorsAre (@"
|
|
0000000000
|
|
0000000000
|
|
0011111000
|
|
0011111000
|
|
0011111000
|
|
0011111000
|
|
0011111000
|
|
0000000000
|
|
0000000000
|
|
0000000000
|
|
", null, attributes);
|
|
|
|
// TODO: In PR #2920 this breaks because the mouse is not grabbed anymore.
|
|
// TODO: Move the mouse grap/drag mode from Toplevel to Border.
|
|
Application.OnMouseEvent (new MouseEventEventArgs (new MouseEvent () { X = 2, Y = 2, Flags = MouseFlags.Button1Pressed }));
|
|
Assert.Equal (d, Application.MouseGrabView);
|
|
|
|
Application.OnMouseEvent (new MouseEventEventArgs (new MouseEvent () { X = 1, Y = 1, Flags = MouseFlags.Button1Pressed | MouseFlags.ReportMousePosition }));
|
|
Application.Refresh ();
|
|
TestHelpers.AssertDriverContentsWithFrameAre (@"
|
|
┌───┐
|
|
│ │
|
|
│ │
|
|
│ │
|
|
└───┘", output);
|
|
|
|
attributes = new Attribute [] {
|
|
// 0
|
|
new Attribute (ColorName.White, ColorName.Black),
|
|
// 1
|
|
Colors.Dialog.Normal
|
|
};
|
|
TestHelpers.AssertDriverColorsAre (@"
|
|
0000000000
|
|
0111110000
|
|
0111110000
|
|
0111110000
|
|
0111110000
|
|
0111110000
|
|
0000000000
|
|
0000000000
|
|
0000000000
|
|
0000000000
|
|
", null, attributes);
|
|
|
|
Application.End (rs);
|
|
Application.Shutdown ();
|
|
}
|
|
|
|
// TODO: Add tests for Run that test errorHandler
|
|
|
|
#endregion
|
|
|
|
#region ShutdownTests
|
|
[Fact]
|
|
public async void Shutdown_Allows_Async ()
|
|
{
|
|
bool isCompletedSuccessfully = false;
|
|
|
|
async Task TaskWithAsyncContinuation ()
|
|
{
|
|
await Task.Yield ();
|
|
await Task.Yield ();
|
|
|
|
isCompletedSuccessfully = true;
|
|
}
|
|
|
|
Init ();
|
|
Application.Shutdown ();
|
|
|
|
Assert.False (isCompletedSuccessfully);
|
|
await TaskWithAsyncContinuation ();
|
|
Thread.Sleep (100);
|
|
Assert.True (isCompletedSuccessfully);
|
|
}
|
|
|
|
[Fact]
|
|
public void Shutdown_Resets_SyncContext ()
|
|
{
|
|
Init ();
|
|
Application.Shutdown ();
|
|
Assert.Null (SynchronizationContext.Current);
|
|
}
|
|
#endregion
|
|
|
|
[Fact, AutoInitShutdown]
|
|
public void Begin_Sets_Application_Top_To_Console_Size ()
|
|
{
|
|
Assert.Equal (new Rect (0, 0, 80, 25), Application.Top.Frame);
|
|
|
|
((FakeDriver)Application.Driver).SetBufferSize (5, 5);
|
|
Application.Begin (Application.Top);
|
|
Assert.Equal (new Rect (0, 0, 80, 25), Application.Top.Frame);
|
|
((FakeDriver)Application.Driver).SetBufferSize (5, 5);
|
|
Assert.Equal (new Rect (0, 0, 5, 5), Application.Top.Frame);
|
|
}
|
|
|
|
[Fact]
|
|
[AutoInitShutdown]
|
|
public void SetCurrentAsTop_Run_A_Not_Modal_Toplevel_Make_It_The_Current_Application_Top ()
|
|
{
|
|
var t1 = new Toplevel ();
|
|
var t2 = new Toplevel ();
|
|
var t3 = new Toplevel ();
|
|
var d = new Dialog ();
|
|
var t4 = new Toplevel ();
|
|
|
|
// t1, t2, t3, d, t4
|
|
var iterations = 5;
|
|
|
|
t1.Ready += (s, e) => {
|
|
Assert.Equal (t1, Application.Top);
|
|
Application.Run (t2);
|
|
};
|
|
t2.Ready += (s, e) => {
|
|
Assert.Equal (t2, Application.Top);
|
|
Application.Run (t3);
|
|
};
|
|
t3.Ready += (s, e) => {
|
|
Assert.Equal (t3, Application.Top);
|
|
Application.Run (d);
|
|
};
|
|
d.Ready += (s, e) => {
|
|
Assert.Equal (t3, Application.Top);
|
|
Application.Run (t4);
|
|
};
|
|
t4.Ready += (s, e) => {
|
|
Assert.Equal (t4, Application.Top);
|
|
t4.RequestStop ();
|
|
d.RequestStop ();
|
|
t3.RequestStop ();
|
|
t2.RequestStop ();
|
|
};
|
|
// Now this will close the OverlappedContainer when all OverlappedChildren was closed
|
|
t2.Closed += (s, _) => {
|
|
t1.RequestStop ();
|
|
};
|
|
Application.Iteration += (s, a) => {
|
|
if (iterations == 5) {
|
|
// The Current still is t4 because Current.Running is false.
|
|
Assert.Equal (t4, Application.Current);
|
|
Assert.False (Application.Current.Running);
|
|
Assert.Equal (t4, Application.Top);
|
|
} else if (iterations == 4) {
|
|
// The Current is d and Current.Running is false.
|
|
Assert.Equal (d, Application.Current);
|
|
Assert.False (Application.Current.Running);
|
|
Assert.Equal (t4, Application.Top);
|
|
} else if (iterations == 3) {
|
|
// The Current is t3 and Current.Running is false.
|
|
Assert.Equal (t3, Application.Current);
|
|
Assert.False (Application.Current.Running);
|
|
Assert.Equal (t3, Application.Top);
|
|
} else if (iterations == 2) {
|
|
// The Current is t2 and Current.Running is false.
|
|
Assert.Equal (t2, Application.Current);
|
|
Assert.False (Application.Current.Running);
|
|
Assert.Equal (t2, Application.Top);
|
|
} else {
|
|
// The Current is t1.
|
|
Assert.Equal (t1, Application.Current);
|
|
Assert.False (Application.Current.Running);
|
|
Assert.Equal (t1, Application.Top);
|
|
}
|
|
iterations--;
|
|
};
|
|
|
|
Application.Run (t1);
|
|
|
|
Assert.Equal (t1, Application.Top);
|
|
}
|
|
|
|
[Fact]
|
|
[AutoInitShutdown]
|
|
public void Internal_Properties_Correct ()
|
|
{
|
|
Assert.True (Application._initialized);
|
|
Assert.NotNull (Application.Top);
|
|
var rs = Application.Begin (Application.Top);
|
|
Assert.Equal (Application.Top, rs.Toplevel);
|
|
Assert.Null (Application.MouseGrabView); // public
|
|
Assert.Null (Application.WantContinuousButtonPressedView); // public
|
|
Assert.False (Application.MoveToOverlappedChild (Application.Top));
|
|
}
|
|
|
|
#region KeyboardTests
|
|
[Fact]
|
|
public void KeyUp_Event ()
|
|
{
|
|
// Setup Mock driver
|
|
Init ();
|
|
|
|
// Setup some fake keypresses (This)
|
|
var input = "Tests";
|
|
|
|
// Put a control-q in at the end
|
|
FakeConsole.MockKeyPresses.Push (new ConsoleKeyInfo ('q', ConsoleKey.Q, shift: false, alt: false, control: true));
|
|
foreach (var c in input.Reverse ()) {
|
|
if (char.IsLetter (c)) {
|
|
FakeConsole.MockKeyPresses.Push (new ConsoleKeyInfo (c, (ConsoleKey)char.ToUpper (c), shift: char.IsUpper (c), alt: false, control: false));
|
|
} else {
|
|
FakeConsole.MockKeyPresses.Push (new ConsoleKeyInfo (c, (ConsoleKey)c, shift: false, alt: false, control: false));
|
|
}
|
|
}
|
|
|
|
int stackSize = FakeConsole.MockKeyPresses.Count;
|
|
|
|
int iterations = 0;
|
|
Application.Iteration += (s, a) => {
|
|
iterations++;
|
|
// Stop if we run out of control...
|
|
if (iterations > 10) {
|
|
Application.RequestStop ();
|
|
}
|
|
};
|
|
|
|
int keyUps = 0;
|
|
var output = string.Empty;
|
|
Application.Top.KeyUp += (object sender, KeyEventEventArgs args) => {
|
|
if (args.KeyEvent.Key != (Key.CtrlMask | Key.Q)) {
|
|
output += (char)args.KeyEvent.KeyValue;
|
|
}
|
|
keyUps++;
|
|
};
|
|
|
|
Application.Run (Application.Top);
|
|
|
|
// Input string should match output
|
|
Assert.Equal (input, output);
|
|
|
|
// # of key up events should match stack size
|
|
//Assert.Equal (stackSize, keyUps);
|
|
// We can't use numbers variables on the left side of an Assert.Equal/NotEqual,
|
|
// it must be literal (Linux only).
|
|
Assert.Equal (6, keyUps);
|
|
|
|
// # of key up events should match # of iterations
|
|
Assert.Equal (stackSize, iterations);
|
|
|
|
Application.Shutdown ();
|
|
Assert.Null (Application.Current);
|
|
Assert.Null (Application.Top);
|
|
Assert.Null (Application.MainLoop);
|
|
Assert.Null (Application.Driver);
|
|
}
|
|
|
|
[Fact]
|
|
public void AlternateForwardKey_AlternateBackwardKey_Tests ()
|
|
{
|
|
Init ();
|
|
|
|
var top = Application.Top;
|
|
var w1 = new Window ();
|
|
var v1 = new TextField ();
|
|
var v2 = new TextView ();
|
|
w1.Add (v1, v2);
|
|
|
|
var w2 = new Window ();
|
|
var v3 = new CheckBox ();
|
|
var v4 = new Button ();
|
|
w2.Add (v3, v4);
|
|
|
|
top.Add (w1, w2);
|
|
|
|
Application.Iteration += (s, a) => {
|
|
Assert.True (v1.HasFocus);
|
|
// Using default keys.
|
|
top.ProcessKey (new KeyEvent (Key.CtrlMask | Key.Tab,
|
|
new KeyModifiers () { Ctrl = true }));
|
|
Assert.True (v2.HasFocus);
|
|
top.ProcessKey (new KeyEvent (Key.CtrlMask | Key.Tab,
|
|
new KeyModifiers () { Ctrl = true }));
|
|
Assert.True (v3.HasFocus);
|
|
top.ProcessKey (new KeyEvent (Key.CtrlMask | Key.Tab,
|
|
new KeyModifiers () { Ctrl = true }));
|
|
Assert.True (v4.HasFocus);
|
|
top.ProcessKey (new KeyEvent (Key.CtrlMask | Key.Tab,
|
|
new KeyModifiers () { Ctrl = true }));
|
|
Assert.True (v1.HasFocus);
|
|
|
|
top.ProcessKey (new KeyEvent (Key.ShiftMask | Key.CtrlMask | Key.Tab,
|
|
new KeyModifiers () { Shift = true, Ctrl = true }));
|
|
Assert.True (v4.HasFocus);
|
|
top.ProcessKey (new KeyEvent (Key.ShiftMask | Key.CtrlMask | Key.Tab,
|
|
new KeyModifiers () { Shift = true, Ctrl = true }));
|
|
Assert.True (v3.HasFocus);
|
|
top.ProcessKey (new KeyEvent (Key.ShiftMask | Key.CtrlMask | Key.Tab,
|
|
new KeyModifiers () { Shift = true, Ctrl = true }));
|
|
Assert.True (v2.HasFocus);
|
|
top.ProcessKey (new KeyEvent (Key.ShiftMask | Key.CtrlMask | Key.Tab,
|
|
new KeyModifiers () { Shift = true, Ctrl = true }));
|
|
Assert.True (v1.HasFocus);
|
|
|
|
top.ProcessKey (new KeyEvent (Key.CtrlMask | Key.PageDown,
|
|
new KeyModifiers () { Ctrl = true }));
|
|
Assert.True (v2.HasFocus);
|
|
top.ProcessKey (new KeyEvent (Key.CtrlMask | Key.PageDown,
|
|
new KeyModifiers () { Ctrl = true }));
|
|
Assert.True (v3.HasFocus);
|
|
top.ProcessKey (new KeyEvent (Key.CtrlMask | Key.PageDown,
|
|
new KeyModifiers () { Ctrl = true }));
|
|
Assert.True (v4.HasFocus);
|
|
top.ProcessKey (new KeyEvent (Key.CtrlMask | Key.PageDown,
|
|
new KeyModifiers () { Ctrl = true }));
|
|
Assert.True (v1.HasFocus);
|
|
|
|
top.ProcessKey (new KeyEvent (Key.CtrlMask | Key.PageUp,
|
|
new KeyModifiers () { Ctrl = true }));
|
|
Assert.True (v4.HasFocus);
|
|
top.ProcessKey (new KeyEvent (Key.CtrlMask | Key.PageUp,
|
|
new KeyModifiers () { Ctrl = true }));
|
|
Assert.True (v3.HasFocus);
|
|
top.ProcessKey (new KeyEvent (Key.CtrlMask | Key.PageUp,
|
|
new KeyModifiers () { Ctrl = true }));
|
|
Assert.True (v2.HasFocus);
|
|
top.ProcessKey (new KeyEvent (Key.CtrlMask | Key.PageUp,
|
|
new KeyModifiers () { Ctrl = true }));
|
|
Assert.True (v1.HasFocus);
|
|
|
|
// Using another's alternate keys.
|
|
Application.AlternateForwardKey = Key.F7;
|
|
Application.AlternateBackwardKey = Key.F6;
|
|
|
|
top.ProcessKey (new KeyEvent (Key.F7, new KeyModifiers ()));
|
|
Assert.True (v2.HasFocus);
|
|
top.ProcessKey (new KeyEvent (Key.F7, new KeyModifiers ()));
|
|
Assert.True (v3.HasFocus);
|
|
top.ProcessKey (new KeyEvent (Key.F7, new KeyModifiers ()));
|
|
Assert.True (v4.HasFocus);
|
|
top.ProcessKey (new KeyEvent (Key.F7, new KeyModifiers ()));
|
|
Assert.True (v1.HasFocus);
|
|
|
|
top.ProcessKey (new KeyEvent (Key.F6, new KeyModifiers ()));
|
|
Assert.True (v4.HasFocus);
|
|
top.ProcessKey (new KeyEvent (Key.F6, new KeyModifiers ()));
|
|
Assert.True (v3.HasFocus);
|
|
top.ProcessKey (new KeyEvent (Key.F6, new KeyModifiers ()));
|
|
Assert.True (v2.HasFocus);
|
|
top.ProcessKey (new KeyEvent (Key.F6, new KeyModifiers ()));
|
|
Assert.True (v1.HasFocus);
|
|
|
|
Application.RequestStop ();
|
|
};
|
|
|
|
Application.Run (top);
|
|
|
|
// Replacing the defaults keys to avoid errors on others unit tests that are using it.
|
|
Application.AlternateForwardKey = Key.PageDown | Key.CtrlMask;
|
|
Application.AlternateBackwardKey = Key.PageUp | Key.CtrlMask;
|
|
Application.QuitKey = Key.Q | Key.CtrlMask;
|
|
|
|
Assert.Equal (Key.PageDown | Key.CtrlMask, Application.AlternateForwardKey);
|
|
Assert.Equal (Key.PageUp | Key.CtrlMask, Application.AlternateBackwardKey);
|
|
Assert.Equal (Key.Q | Key.CtrlMask, Application.QuitKey);
|
|
|
|
// Shutdown must be called to safely clean up Application if Init has been called
|
|
Application.Shutdown ();
|
|
}
|
|
|
|
[Fact]
|
|
[AutoInitShutdown]
|
|
public void QuitKey_Getter_Setter ()
|
|
{
|
|
var top = Application.Top;
|
|
var isQuiting = false;
|
|
|
|
top.Closing += (s, e) => {
|
|
isQuiting = true;
|
|
e.Cancel = true;
|
|
};
|
|
|
|
Application.Begin (top);
|
|
top.Running = true;
|
|
|
|
Assert.Equal (Key.Q | Key.CtrlMask, Application.QuitKey);
|
|
Application.Driver.SendKeys ('q', ConsoleKey.Q, false, false, true);
|
|
Assert.True (isQuiting);
|
|
|
|
isQuiting = false;
|
|
Application.QuitKey = Key.C | Key.CtrlMask;
|
|
|
|
Application.Driver.SendKeys ('q', ConsoleKey.Q, false, false, true);
|
|
Assert.False (isQuiting);
|
|
Application.Driver.SendKeys ('c', ConsoleKey.C, false, false, true);
|
|
Assert.True (isQuiting);
|
|
|
|
// Reset the QuitKey to avoid throws errors on another tests
|
|
Application.QuitKey = Key.Q | Key.CtrlMask;
|
|
}
|
|
|
|
[Fact]
|
|
[AutoInitShutdown]
|
|
public void EnsuresTopOnFront_CanFocus_True_By_Keyboard_And_Mouse ()
|
|
{
|
|
var top = Application.Top;
|
|
var win = new Window () { Title = "win", X = 0, Y = 0, Width = 20, Height = 10 };
|
|
var tf = new TextField () { Width = 10 };
|
|
win.Add (tf);
|
|
var win2 = new Window () { Title = "win2", X = 22, Y = 0, Width = 20, Height = 10 };
|
|
var tf2 = new TextField () { Width = 10 };
|
|
win2.Add (tf2);
|
|
top.Add (win, win2);
|
|
|
|
Application.Begin (top);
|
|
|
|
Assert.True (win.CanFocus);
|
|
Assert.True (win.HasFocus);
|
|
Assert.True (win2.CanFocus);
|
|
Assert.False (win2.HasFocus);
|
|
Assert.Equal ("win2", ((Window)top.Subviews [top.Subviews.Count - 1]).Title);
|
|
|
|
top.ProcessKey (new KeyEvent (Key.CtrlMask | Key.Tab, new KeyModifiers ()));
|
|
Assert.True (win.CanFocus);
|
|
Assert.False (win.HasFocus);
|
|
Assert.True (win2.CanFocus);
|
|
Assert.True (win2.HasFocus);
|
|
Assert.Equal ("win2", ((Window)top.Subviews [top.Subviews.Count - 1]).Title);
|
|
|
|
top.ProcessKey (new KeyEvent (Key.CtrlMask | Key.Tab, new KeyModifiers ()));
|
|
Assert.True (win.CanFocus);
|
|
Assert.True (win.HasFocus);
|
|
Assert.True (win2.CanFocus);
|
|
Assert.False (win2.HasFocus);
|
|
Assert.Equal ("win", ((Window)top.Subviews [top.Subviews.Count - 1]).Title);
|
|
|
|
win2.MouseEvent (new MouseEvent () { Flags = MouseFlags.Button1Pressed });
|
|
Assert.True (win.CanFocus);
|
|
Assert.False (win.HasFocus);
|
|
Assert.True (win2.CanFocus);
|
|
Assert.True (win2.HasFocus);
|
|
Assert.Equal ("win2", ((Window)top.Subviews [top.Subviews.Count - 1]).Title);
|
|
win2.MouseEvent (new MouseEvent () { Flags = MouseFlags.Button1Released });
|
|
Assert.Null (Toplevel._dragPosition);
|
|
}
|
|
|
|
[Fact]
|
|
[AutoInitShutdown]
|
|
public void EnsuresTopOnFront_CanFocus_False_By_Keyboard_And_Mouse ()
|
|
{
|
|
var top = Application.Top;
|
|
var win = new Window () { Title = "win", X = 0, Y = 0, Width = 20, Height = 10 };
|
|
var tf = new TextField () { Width = 10 };
|
|
win.Add (tf);
|
|
var win2 = new Window () { Title = "win2", X = 22, Y = 0, Width = 20, Height = 10 };
|
|
var tf2 = new TextField () { Width = 10 };
|
|
win2.Add (tf2);
|
|
top.Add (win, win2);
|
|
|
|
Application.Begin (top);
|
|
|
|
Assert.True (win.CanFocus);
|
|
Assert.True (win.HasFocus);
|
|
Assert.True (win2.CanFocus);
|
|
Assert.False (win2.HasFocus);
|
|
Assert.Equal ("win2", ((Window)top.Subviews [top.Subviews.Count - 1]).Title);
|
|
|
|
win.CanFocus = false;
|
|
Assert.False (win.CanFocus);
|
|
Assert.False (win.HasFocus);
|
|
Assert.True (win2.CanFocus);
|
|
Assert.True (win2.HasFocus);
|
|
Assert.Equal ("win2", ((Window)top.Subviews [top.Subviews.Count - 1]).Title);
|
|
|
|
top.ProcessKey (new KeyEvent (Key.CtrlMask | Key.Tab, new KeyModifiers ()));
|
|
Assert.True (win2.CanFocus);
|
|
Assert.False (win.HasFocus);
|
|
Assert.True (win2.CanFocus);
|
|
Assert.True (win2.HasFocus);
|
|
Assert.Equal ("win2", ((Window)top.Subviews [top.Subviews.Count - 1]).Title);
|
|
|
|
top.ProcessKey (new KeyEvent (Key.CtrlMask | Key.Tab, new KeyModifiers ()));
|
|
Assert.False (win.CanFocus);
|
|
Assert.False (win.HasFocus);
|
|
Assert.True (win2.CanFocus);
|
|
Assert.True (win2.HasFocus);
|
|
Assert.Equal ("win2", ((Window)top.Subviews [top.Subviews.Count - 1]).Title);
|
|
|
|
win.MouseEvent (new MouseEvent () { Flags = MouseFlags.Button1Pressed });
|
|
Assert.False (win.CanFocus);
|
|
Assert.False (win.HasFocus);
|
|
Assert.True (win2.CanFocus);
|
|
Assert.True (win2.HasFocus);
|
|
Assert.Equal ("win2", ((Window)top.Subviews [top.Subviews.Count - 1]).Title);
|
|
win2.MouseEvent (new MouseEvent () { Flags = MouseFlags.Button1Released });
|
|
Assert.Null (Toplevel._dragPosition);
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
// Invoke Tests
|
|
// TODO: Test with threading scenarios
|
|
[Fact]
|
|
public void Invoke_Adds_Idle ()
|
|
{
|
|
Application.Init (new FakeDriver ());
|
|
var top = new Toplevel ();
|
|
var rs = Application.Begin (top);
|
|
bool firstIteration = false;
|
|
|
|
var actionCalled = 0;
|
|
Application.Invoke (() => { actionCalled++; });
|
|
Application.RunIteration (ref rs, ref firstIteration);
|
|
Assert.Equal (1, actionCalled);
|
|
Application.Shutdown ();
|
|
}
|
|
} |