mirror of
https://github.com/gui-cs/Terminal.Gui.git
synced 2025-12-26 15:57:56 +01:00
fdeaa8331b
* Refactored test namespaces. Moved some tests that were in wrong project. Code cleanup * Parrallel -> Parallel
260 lines
9.8 KiB
C#
260 lines
9.8 KiB
C#
using System.Text;
|
|
using Xunit.Abstractions;
|
|
|
|
// Alias Console to MockConsole so we don't accidentally use Console
|
|
using Console = Terminal.Gui.Drivers.FakeConsole;
|
|
|
|
namespace UnitTests.DriverTests;
|
|
|
|
public class ConsoleDriverTests
|
|
{
|
|
private readonly ITestOutputHelper _output;
|
|
|
|
public ConsoleDriverTests (ITestOutputHelper output)
|
|
{
|
|
ConsoleDriver.RunningUnitTests = true;
|
|
_output = output;
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData (typeof (FakeDriver))]
|
|
//[InlineData (typeof (DotNetDriver))]
|
|
|
|
//[InlineData (typeof (ANSIDriver))]
|
|
//[InlineData (typeof (WindowsDriver))]
|
|
//[InlineData (typeof (UnixDriver))]
|
|
public void End_Cleans_Up (Type driverType)
|
|
{
|
|
var driver = (IConsoleDriver)Activator.CreateInstance (driverType);
|
|
driver.Init ();
|
|
driver.End ();
|
|
}
|
|
|
|
// NOTE: These tests were removed because they use legacy FakeDriver patterns that don't work with modern architecture:
|
|
// 1. They use Console.MockKeyPresses which is a legacy FakeDriver pattern
|
|
// 2. Application.Run() with the legacy FakeDriver doesn't properly process MockKeyPresses in modern architecture
|
|
// 3. These tests should be rewritten to use the modern FakeComponentFactory with predefined input
|
|
// 4. Key press handling should be tested through the input processor layer, not driver tests
|
|
//
|
|
// [Theory]
|
|
// [InlineData (typeof (FakeDriver))]
|
|
// public void FakeDriver_MockKeyPresses (Type driverType)
|
|
|
|
[Theory]
|
|
[InlineData (typeof (FakeDriver))]
|
|
//[InlineData (typeof (DotNetDriver))]
|
|
|
|
//[InlineData (typeof (ANSIDriver))]
|
|
//[InlineData (typeof (WindowsDriver))]
|
|
//[InlineData (typeof (UnixDriver))]
|
|
public void Init_Inits (Type driverType)
|
|
{
|
|
var driver = (IConsoleDriver)Activator.CreateInstance (driverType);
|
|
MainLoop ml = driver.Init ();
|
|
Assert.NotNull (ml);
|
|
Assert.NotNull (driver.Clipboard);
|
|
Console.ForegroundColor = ConsoleColor.Red;
|
|
Assert.Equal (ConsoleColor.Red, Console.ForegroundColor);
|
|
Console.BackgroundColor = ConsoleColor.Green;
|
|
Assert.Equal (ConsoleColor.Green, Console.BackgroundColor);
|
|
|
|
driver.End ();
|
|
}
|
|
|
|
//[Theory]
|
|
//[InlineData (typeof (FakeDriver))]
|
|
//public void FakeDriver_MockKeyPresses_Press_AfterTimeOut (Type driverType)
|
|
//{
|
|
// var driver = (IConsoleDriver)Activator.CreateInstance (driverType);
|
|
// Application.Init (driver);
|
|
|
|
// // Simulating pressing of QuitKey after a short period of time
|
|
// uint quitTime = 100;
|
|
// Func<MainLoop, bool> closeCallback = (MainLoop loop) => {
|
|
// // Prove the scenario is using Application.QuitKey correctly
|
|
// output.WriteLine ($" {quitTime}ms elapsed; Simulating keypresses...");
|
|
// FakeConsole.PushMockKeyPress (Key.F);
|
|
// FakeConsole.PushMockKeyPress (Key.U);
|
|
// FakeConsole.PushMockKeyPress (Key.C);
|
|
// FakeConsole.PushMockKeyPress (Key.K);
|
|
// return false;
|
|
// };
|
|
// output.WriteLine ($"Add timeout to simulate key presses after {quitTime}ms");
|
|
// _ = Application.AddTimeout (TimeSpan.FromMilliseconds (quitTime), closeCallback);
|
|
|
|
// // If Top doesn't quit within abortTime * 5 (500ms), this will force it
|
|
// uint abortTime = quitTime * 5;
|
|
// Func<MainLoop, bool> forceCloseCallback = (MainLoop loop) => {
|
|
// Application.RequestStop ();
|
|
// Assert.Fail ($" failed to Quit after {abortTime}ms. Force quit.");
|
|
// return false;
|
|
// };
|
|
// output.WriteLine ($"Add timeout to force quit after {abortTime}ms");
|
|
// _ = Application.AddTimeout (TimeSpan.FromMilliseconds (abortTime), forceCloseCallback);
|
|
|
|
// Key key = Key.Unknown;
|
|
|
|
// Application.Top.KeyPress += (e) => {
|
|
// key = e.Key;
|
|
// output.WriteLine ($" Application.Top.KeyPress: {key}");
|
|
// e.Handled = true;
|
|
|
|
// };
|
|
|
|
// int iterations = 0;
|
|
// Application.Iteration += (s, a) => {
|
|
// output.WriteLine ($" iteration {++iterations}");
|
|
|
|
// if (Console.MockKeyPresses.Count == 0) {
|
|
// output.WriteLine ($" No more MockKeyPresses; RequestStop");
|
|
// Application.RequestStop ();
|
|
// }
|
|
// };
|
|
|
|
// Application.Run ();
|
|
|
|
// // Shutdown must be called to safely clean up Application if Init has been called
|
|
// Application.Shutdown ();
|
|
//}
|
|
|
|
[Theory]
|
|
[InlineData (typeof (FakeDriver))]
|
|
//[InlineData (typeof (DotNetDriver))]
|
|
|
|
//[InlineData (typeof (ANSIDriver))]
|
|
//[InlineData (typeof (WindowsDriver))]
|
|
//[InlineData (typeof (UnixDriver))]
|
|
public void TerminalResized_Simulation (Type driverType)
|
|
{
|
|
var driver = (IConsoleDriver)Activator.CreateInstance (driverType);
|
|
driver?.Init ();
|
|
driver.Cols = 80;
|
|
driver.Rows = 25;
|
|
|
|
var wasTerminalResized = false;
|
|
|
|
driver.SizeChanged += (s, e) =>
|
|
{
|
|
wasTerminalResized = true;
|
|
Assert.Equal (120, e.Size.GetValueOrDefault ().Width);
|
|
Assert.Equal (40, e.Size.GetValueOrDefault ().Height);
|
|
};
|
|
|
|
Assert.Equal (80, driver.Cols);
|
|
Assert.Equal (25, driver.Rows);
|
|
Assert.False (wasTerminalResized);
|
|
|
|
driver.Cols = 120;
|
|
driver.Rows = 40;
|
|
|
|
((ConsoleDriver)driver).OnSizeChanged (new SizeChangedEventArgs (new (driver.Cols, driver.Rows)));
|
|
Assert.Equal (120, driver.Cols);
|
|
Assert.Equal (40, driver.Rows);
|
|
Assert.True (wasTerminalResized);
|
|
driver.End ();
|
|
}
|
|
|
|
// Disabled due to test error - Change Task.Delay to an await
|
|
// [Fact, AutoInitShutdown]
|
|
// public void Write_Do_Not_Change_On_ProcessKey ()
|
|
// {
|
|
// var win = new Window ();
|
|
// Application.Begin (win);
|
|
// AutoInitShutdownAttribute.FakeResize(new Size ( (20, 8);
|
|
|
|
// System.Threading.Tasks.Task.Run (() => {
|
|
// System.Threading.Tasks.Task.Delay (500).Wait ();
|
|
// Application.Invoke (() => {
|
|
// var lbl = new Label ("Hello World") { X = Pos.Center () };
|
|
// var dlg = new Dialog ();
|
|
// dlg.Add (lbl);
|
|
// Application.Begin (dlg);
|
|
|
|
// var expected = @"
|
|
//┌──────────────────┐
|
|
//│┌───────────────┐ │
|
|
//││ Hello World │ │
|
|
//││ │ │
|
|
//││ │ │
|
|
//││ │ │
|
|
//│└───────────────┘ │
|
|
//└──────────────────┘
|
|
//";
|
|
|
|
// var pos = DriverAsserts.AssertDriverContentsWithFrameAre (expected, output);
|
|
// Assert.Equal (new (0, 0, 20, 8), pos);
|
|
|
|
// Assert.True (dlg.ProcessKey (new (Key.Tab)));
|
|
// dlg.Draw ();
|
|
|
|
// expected = @"
|
|
//┌──────────────────┐
|
|
//│┌───────────────┐ │
|
|
//││ Hello World │ │
|
|
//││ │ │
|
|
//││ │ │
|
|
//││ │ │
|
|
//│└───────────────┘ │
|
|
//└──────────────────┘
|
|
//";
|
|
|
|
// pos = DriverAsserts.AssertDriverContentsWithFrameAre (expected, output);
|
|
// Assert.Equal (new (0, 0, 20, 8), pos);
|
|
|
|
// win.RequestStop ();
|
|
// });
|
|
// });
|
|
|
|
// Application.Run (win);
|
|
// Application.Shutdown ();
|
|
// }
|
|
|
|
// NOTE: This test was removed because:
|
|
// 1. It hangs indefinitely - the Application.Run loop never exits properly with modern architecture
|
|
// 2. It's testing general surrogate pair/input handling, not FakeDriver-specific functionality
|
|
// 3. It uses legacy FakeDriver patterns (Console.MockKeyPresses) that don't work correctly with modern architecture
|
|
// 4. Surrogate pair handling should be tested in input processor tests, not driver tests
|
|
// 5. The test accesses private field _highSurrogate which is an implementation detail
|
|
//
|
|
// [Theory]
|
|
// [InlineData ('\ud83d', '\udcc4')] // This seems right sequence but Stack is LIFO
|
|
// [InlineData ('\ud83d', '\ud83d')]
|
|
// [InlineData ('\udcc4', '\udcc4')]
|
|
// public void FakeDriver_IsValidInput_Wrong_Surrogate_Sequence (char c1, char c2)
|
|
|
|
// NOTE: This test was also removed for the same reasons as FakeDriver_IsValidInput_Wrong_Surrogate_Sequence:
|
|
// 1. It hangs indefinitely - the Application.Run loop never exits properly with modern architecture
|
|
// 2. It's testing general surrogate pair/input handling, not FakeDriver-specific functionality
|
|
// 3. It uses legacy FakeDriver patterns (Console.MockKeyPresses) that don't work correctly with modern architecture
|
|
// 4. Surrogate pair handling should be tested in input processor tests, not driver tests
|
|
//
|
|
// [Fact]
|
|
// public void FakeDriver_IsValidInput_Correct_Surrogate_Sequence ()
|
|
|
|
/// <summary>
|
|
/// Tests that when ConsoleDriver.RunningUnitTests is true, Application.Init() without
|
|
/// parameters uses FakeDriver instead of platform-specific drivers.
|
|
/// This prevents intermittent failures on macOS where kernel32.dll might be referenced.
|
|
/// </summary>
|
|
[Fact]
|
|
public void Application_Init_Without_Params_Uses_FakeDriver_When_RunningUnitTests ()
|
|
{
|
|
// Arrange
|
|
ConsoleDriver.RunningUnitTests = true;
|
|
Application.ResetState (true);
|
|
|
|
// Act
|
|
Application.Init ();
|
|
|
|
// Assert
|
|
Assert.NotNull (Application.Driver);
|
|
// In the modern v2 architecture, the driver will be a ConsoleDriverFacade wrapping FakeDriver
|
|
// The key is that it's not attempting to use Windows/Unix platform-specific drivers
|
|
Assert.True (Application.Initialized);
|
|
|
|
// Cleanup
|
|
Application.Shutdown ();
|
|
Application.ResetState (true);
|
|
}
|
|
}
|