Merge branch 'develop' into fs

UnitTests/Application/ApplicationTests.cs

@@ -24,6 +24,7 @@ namespace Terminal.Gui.ApplicationTests {
 			Assert.Null (Application.Driver);
 			Assert.Null (Application.Top);
 			Assert.Null (Application.Current);
+			Assert.False (Application.EnableConsoleScrolling);
 			Assert.Null (Application.MainLoop);
 			Assert.Null (Application.Iteration);
 			Assert.Null (Application.RootMouseEvent);
@@ -35,7 +36,7 @@ namespace Terminal.Gui.ApplicationTests {
 			Assert.NotNull (Application.Driver);
 			Assert.NotNull (Application.Top);
 			Assert.NotNull (Application.Current);
-			Assert.False (Application.HeightAsBuffer);
+			Assert.False (Application.EnableConsoleScrolling);
 			Assert.NotNull (Application.MainLoop);
 			Assert.Null (Application.Iteration);
 			Assert.Null (Application.RootMouseEvent);
@@ -312,7 +313,7 @@ namespace Terminal.Gui.ApplicationTests {
 		public void Run_T_Init_Driver_Cleared_with_TestTopLevel_Throws ()
 		{
 			Init ();
-			
+
 			Application.Driver = null;
 
 			Application.Iteration = () => {
@@ -332,8 +333,8 @@ namespace Terminal.Gui.ApplicationTests {
 		[Fact]
 		public void Run_T_NoInit_DoesNotThrow ()
 		{
-			Application.ForceFakeConsole = true; 
-			
+			Application.ForceFakeConsole = true;
+
 			Application.Iteration = () => {
 				Application.RequestStop ();
 			};
@@ -429,7 +430,7 @@ namespace Terminal.Gui.ApplicationTests {
 		}
 
 		// TODO: Add tests for Run that test errorHandler
-		
+
 		#endregion
 
 		#region ShutdownTests

UnitTests/Core/BorderTests.cs

@@ -228,7 +228,12 @@ namespace Terminal.Gui.CoreTests {
 
 					var color = (Attribute)driver.Contents [r, c, 1];
 					var rune = (Rune)driver.Contents [r, c, 0];
-					Assert.Equal (Color.Black, color.Background);
+					if (r == frame.Y - drawMarginFrame || r == frame.Bottom + drawMarginFrame - 1
+						|| c == frame.X - drawMarginFrame || c == frame.Right + drawMarginFrame - 1) {
+						Assert.Equal (Color.BrightGreen, color.Background);
+					} else {
+						Assert.Equal (Color.Black, color.Background);
+					}
 					if (c == frame.X - drawMarginFrame && r == frame.Y - drawMarginFrame) {
 						Assert.Equal (uLCorner, rune);
 					} else if (c == frame.Right && r == frame.Y - drawMarginFrame) {
@@ -457,7 +462,12 @@ namespace Terminal.Gui.CoreTests {
 
 					var color = (Attribute)driver.Contents [r, c, 1];
 					var rune = (Rune)driver.Contents [r, c, 0];
-					Assert.Equal (Color.Black, color.Background);
+					if (r == frame.Y + sumThickness.Top || r == frame.Bottom - sumThickness.Bottom - 1
+						|| c == frame.X + sumThickness.Left || c == frame.Right - sumThickness.Right - 1) {
+						Assert.Equal (Color.BrightGreen, color.Background);
+					} else {
+						Assert.Equal (Color.Black, color.Background);
+					}
 					if (c == frame.X + sumThickness.Left && r == frame.Y + sumThickness.Top) {
 						Assert.Equal (uLCorner, rune);
 					} else if (c == frame.Right - drawMarginFrame - sumThickness.Right

UnitTests/Core/EscSeqReqTests.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Terminal.Gui.CoreTests {
+	public class EscSeqReqTests {
+		[Fact]
+		public void Constructor_Defaults ()
+		{
+			var escSeqReq = new EscSeqReqProc ();
+			Assert.NotNull (escSeqReq.EscSeqReqStats);
+			Assert.Empty (escSeqReq.EscSeqReqStats);
+		}
+
+		[Fact]
+		public void Add_Tests ()
+		{
+			var escSeqReq = new EscSeqReqProc ();
+			escSeqReq.Add ("t");
+			Assert.Single (escSeqReq.EscSeqReqStats);
+			Assert.Equal ("t", escSeqReq.EscSeqReqStats [^1].Terminating);
+			Assert.Equal (1, escSeqReq.EscSeqReqStats [^1].NumRequests);
+			Assert.Equal (1, escSeqReq.EscSeqReqStats [^1].NumOutstanding);
+
+			escSeqReq.Add ("t", 2);
+			Assert.Single (escSeqReq.EscSeqReqStats);
+			Assert.Equal ("t", escSeqReq.EscSeqReqStats [^1].Terminating);
+			Assert.Equal (1, escSeqReq.EscSeqReqStats [^1].NumRequests);
+			Assert.Equal (1, escSeqReq.EscSeqReqStats [^1].NumOutstanding);
+
+			escSeqReq = new EscSeqReqProc ();
+			escSeqReq.Add ("t", 2);
+			Assert.Single (escSeqReq.EscSeqReqStats);
+			Assert.Equal ("t", escSeqReq.EscSeqReqStats [^1].Terminating);
+			Assert.Equal (2, escSeqReq.EscSeqReqStats [^1].NumRequests);
+			Assert.Equal (2, escSeqReq.EscSeqReqStats [^1].NumOutstanding);
+
+			escSeqReq.Add ("t", 3);
+			Assert.Single (escSeqReq.EscSeqReqStats);
+			Assert.Equal ("t", escSeqReq.EscSeqReqStats [^1].Terminating);
+			Assert.Equal (2, escSeqReq.EscSeqReqStats [^1].NumRequests);
+			Assert.Equal (2, escSeqReq.EscSeqReqStats [^1].NumOutstanding);
+		}
+
+		[Fact]
+		public void Remove_Tests ()
+		{
+			var escSeqReq = new EscSeqReqProc ();
+			escSeqReq.Add ("t");
+			escSeqReq.Remove ("t");
+			Assert.Empty (escSeqReq.EscSeqReqStats);
+
+			escSeqReq.Add ("t", 2);
+			escSeqReq.Remove ("t");
+			Assert.Single (escSeqReq.EscSeqReqStats);
+			Assert.Equal ("t", escSeqReq.EscSeqReqStats [^1].Terminating);
+			Assert.Equal (2, escSeqReq.EscSeqReqStats [^1].NumRequests);
+			Assert.Equal (1, escSeqReq.EscSeqReqStats [^1].NumOutstanding);
+
+			escSeqReq.Remove ("t");
+			Assert.Empty (escSeqReq.EscSeqReqStats);
+		}
+
+		[Fact]
+		public void Requested_Tests ()
+		{
+			var escSeqReq = new EscSeqReqProc ();
+			Assert.False (escSeqReq.Requested ("t"));
+
+			escSeqReq.Add ("t");
+			Assert.False (escSeqReq.Requested ("r"));
+			Assert.True (escSeqReq.Requested ("t"));
+		}
+	}
+}

UnitTests/Core/EscSeqUtilsTests.cs

@@ -0,0 +1,870 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using Xunit;
+
+namespace Terminal.Gui.CoreTests {
+	public class EscSeqUtilsTests {
+		[Fact]
+		public void Defaults_Values ()
+		{
+			Assert.Equal ('\x1b', EscSeqUtils.KeyEsc);
+			Assert.Equal ("\x1b[", EscSeqUtils.KeyCSI);
+			Assert.Equal ("\x1b[?1003h", EscSeqUtils.CSI_EnableAnyEventMouse);
+			Assert.Equal ("\x1b[?1006h", EscSeqUtils.CSI_EnableSgrExtModeMouse);
+			Assert.Equal ("\x1b[?1015h", EscSeqUtils.CSI_EnableUrxvtExtModeMouse);
+			Assert.Equal ("\x1b[?1003l", EscSeqUtils.CSI_DisableAnyEventMouse);
+			Assert.Equal ("\x1b[?1006l", EscSeqUtils.CSI_DisableSgrExtModeMouse);
+			Assert.Equal ("\x1b[?1015l", EscSeqUtils.CSI_DisableUrxvtExtModeMouse);
+			Assert.Equal ("\x1b[?1003h\x1b[?1015h\u001b[?1006h", EscSeqUtils.EnableMouseEvents);
+			Assert.Equal ("\x1b[?1003l\x1b[?1015l\u001b[?1006l", EscSeqUtils.DisableMouseEvents);
+		}
+
+		[Fact]
+		public void GetConsoleInputKey_ConsoleKeyInfo ()
+		{
+			var cki = new ConsoleKeyInfo ('r', 0, false, false, false);
+			var expectedCki = new ConsoleKeyInfo ('r', 0, false, false, false);
+			Assert.Equal (expectedCki, EscSeqUtils.GetConsoleInputKey (cki));
+
+			cki = new ConsoleKeyInfo ('r', 0, true, false, false);
+			expectedCki = new ConsoleKeyInfo ('r', 0, true, false, false);
+			Assert.Equal (expectedCki, EscSeqUtils.GetConsoleInputKey (cki));
+
+			cki = new ConsoleKeyInfo ('r', 0, false, true, false);
+			expectedCki = new ConsoleKeyInfo ('r', 0, false, true, false);
+			Assert.Equal (expectedCki, EscSeqUtils.GetConsoleInputKey (cki));
+
+			cki = new ConsoleKeyInfo ('r', 0, false, false, true);
+			expectedCki = new ConsoleKeyInfo ('r', 0, false, false, true);
+			Assert.Equal (expectedCki, EscSeqUtils.GetConsoleInputKey (cki));
+
+			cki = new ConsoleKeyInfo ('r', 0, true, true, false);
+			expectedCki = new ConsoleKeyInfo ('r', 0, true, true, false);
+			Assert.Equal (expectedCki, EscSeqUtils.GetConsoleInputKey (cki));
+
+			cki = new ConsoleKeyInfo ('r', 0, false, true, true);
+			expectedCki = new ConsoleKeyInfo ('r', 0, false, true, true);
+			Assert.Equal (expectedCki, EscSeqUtils.GetConsoleInputKey (cki));
+
+			cki = new ConsoleKeyInfo ('r', 0, true, true, true);
+			expectedCki = new ConsoleKeyInfo ('r', 0, true, true, true);
+			Assert.Equal (expectedCki, EscSeqUtils.GetConsoleInputKey (cki));
+
+			cki = new ConsoleKeyInfo ('\u0012', 0, false, false, false);
+			expectedCki = new ConsoleKeyInfo ('R', ConsoleKey.R, false, false, true);
+			Assert.Equal (expectedCki, EscSeqUtils.GetConsoleInputKey (cki));
+
+			cki = new ConsoleKeyInfo ('\0', (ConsoleKey)64, false, false, true);
+			expectedCki = new ConsoleKeyInfo (' ', ConsoleKey.Spacebar, false, false, true);
+			Assert.Equal (expectedCki, EscSeqUtils.GetConsoleInputKey (cki));
+
+			cki = new ConsoleKeyInfo ('\r', 0, false, false, false);
+			expectedCki = new ConsoleKeyInfo ('\r', ConsoleKey.Enter, false, false, false);
+			Assert.Equal (expectedCki, EscSeqUtils.GetConsoleInputKey (cki));
+
+			cki = new ConsoleKeyInfo ('\u007f', 0, false, false, false);
+			expectedCki = new ConsoleKeyInfo ('\u007f', ConsoleKey.Backspace, false, false, false);
+			Assert.Equal (expectedCki, EscSeqUtils.GetConsoleInputKey (cki));
+
+			cki = new ConsoleKeyInfo ('R', 0, false, false, false);
+			expectedCki = new ConsoleKeyInfo ('R', 0, false, false, false);
+			Assert.Equal (expectedCki, EscSeqUtils.GetConsoleInputKey (cki));
+		}
+
+		[Fact]
+		public void ResizeArray_ConsoleKeyInfo ()
+		{
+			ConsoleKeyInfo [] expectedCkInfos = null;
+			var cki = new ConsoleKeyInfo ('\u001b', ConsoleKey.Escape, false, false, false);
+			expectedCkInfos = EscSeqUtils.ResizeArray (cki, expectedCkInfos);
+			Assert.Single (expectedCkInfos);
+			Assert.Equal (cki, expectedCkInfos [0]);
+		}
+
+		private EscSeqReqProc escSeqReqProc;
+		private ConsoleKeyInfo newConsoleKeyInfo;
+		private ConsoleKey key;
+		private ConsoleKeyInfo [] cki;
+		private ConsoleModifiers mod;
+		private string c1Control, code, terminating;
+		private string [] values;
+		private bool isKeyMouse;
+		private bool isReq;
+		private List<MouseFlags> mouseFlags;
+		Point pos;
+		private MouseFlags arg1;
+		private Point arg2;
+		private bool actionStarted;
+
+		[Fact, AutoInitShutdown]
+		public void DecodeEscSeq_Tests ()
+		{
+			// ESC
+			cki = new ConsoleKeyInfo [] { new ConsoleKeyInfo ('\u001b', 0, false, false, false) };
+			var expectedCki = new ConsoleKeyInfo ('\u001b', ConsoleKey.Escape, false, false, false);
+			EscSeqUtils.DecodeEscSeq (escSeqReqProc, ref newConsoleKeyInfo, ref key, cki, ref mod, out c1Control, out code, out values, out terminating, out isKeyMouse, out mouseFlags, out pos, out isReq, ProcessContinuousButtonPressed);
+			Assert.Null (escSeqReqProc);
+			Assert.Equal (expectedCki, newConsoleKeyInfo);
+			Assert.Equal (ConsoleKey.Escape, key);
+			Assert.Equal (0, (int)mod);
+			Assert.Equal ("ESC", c1Control);
+			Assert.Null (code);
+			Assert.Null (values);
+			Assert.Null (terminating);
+			Assert.False (isKeyMouse);
+			Assert.Equal (new List<MouseFlags> () { 0 }, mouseFlags);
+			Assert.Equal (Point.Empty, pos);
+			Assert.False (isReq);
+			Assert.Equal (0, (int)arg1);
+			Assert.Equal (Point.Empty, arg2);
+
+			ClearAll ();
+			cki = new ConsoleKeyInfo [] {
+				new ConsoleKeyInfo ('\u001b', 0, false, false, false),
+				new ConsoleKeyInfo ('\u0012', 0, false, false, false)
+			};
+			expectedCki = new ConsoleKeyInfo ('\u0012', ConsoleKey.R, false, true, true);
+			EscSeqUtils.DecodeEscSeq (escSeqReqProc, ref newConsoleKeyInfo, ref key, cki, ref mod, out c1Control, out code, out values, out terminating, out isKeyMouse, out mouseFlags, out pos, out isReq, ProcessContinuousButtonPressed);
+			Assert.Null (escSeqReqProc);
+			Assert.Equal (expectedCki, newConsoleKeyInfo);
+			Assert.Equal (ConsoleKey.R, key);
+			Assert.Equal (0, (int)mod);
+			Assert.Equal ("ESC", c1Control);
+			Assert.Null (code);
+			Assert.Null (values);
+			Assert.Equal ("\u0012", terminating);
+			Assert.False (isKeyMouse);
+			Assert.Equal (new List<MouseFlags> () { 0 }, mouseFlags);
+			Assert.Equal (Point.Empty, pos);
+			Assert.False (isReq);
+			Assert.Equal (0, (int)arg1);
+			Assert.Equal (Point.Empty, arg2);
+
+			ClearAll ();
+			cki = new ConsoleKeyInfo [] {
+				new ConsoleKeyInfo ('\u001b', 0, false, false, false),
+				new ConsoleKeyInfo ('r', 0, false, false, false)
+			};
+			expectedCki = new ConsoleKeyInfo ('R', ConsoleKey.R, false, true, false);
+			EscSeqUtils.DecodeEscSeq (escSeqReqProc, ref newConsoleKeyInfo, ref key, cki, ref mod, out c1Control, out code, out values, out terminating, out isKeyMouse, out mouseFlags, out pos, out isReq, ProcessContinuousButtonPressed);
+			Assert.Null (escSeqReqProc);
+			Assert.Equal (expectedCki, newConsoleKeyInfo);
+			Assert.Equal (ConsoleKey.R, key);
+			Assert.Equal (0, (int)mod);
+			Assert.Equal ("ESC", c1Control);
+			Assert.Null (code);
+			Assert.Null (values);
+			Assert.Equal ("r", terminating);
+			Assert.False (isKeyMouse);
+			Assert.Equal (new List<MouseFlags> () { 0 }, mouseFlags);
+			Assert.Equal (Point.Empty, pos);
+			Assert.False (isReq);
+			Assert.Equal (0, (int)arg1);
+			Assert.Equal (Point.Empty, arg2);
+
+			// SS3
+			ClearAll ();
+			cki = new ConsoleKeyInfo [] {
+				new ConsoleKeyInfo ('\u001b', 0, false, false, false),
+				new ConsoleKeyInfo ('O', 0, false, false, false),
+				new ConsoleKeyInfo ('R', 0, false, false, false)
+			};
+			expectedCki = new ConsoleKeyInfo ('\0', ConsoleKey.F3, false, false, false);
+			EscSeqUtils.DecodeEscSeq (escSeqReqProc, ref newConsoleKeyInfo, ref key, cki, ref mod, out c1Control, out code, out values, out terminating, out isKeyMouse, out mouseFlags, out pos, out isReq, ProcessContinuousButtonPressed);
+			Assert.Null (escSeqReqProc);
+			Assert.Equal (expectedCki, newConsoleKeyInfo);
+			Assert.Equal (ConsoleKey.F3, key);
+			Assert.Equal (0, (int)mod);
+			Assert.Equal ("SS3", c1Control);
+			Assert.Null (code);
+			Assert.Single (values);
+			Assert.Null (values [0]);
+			Assert.Equal ("R", terminating);
+			Assert.False (isKeyMouse);
+			Assert.Equal (new List<MouseFlags> () { 0 }, mouseFlags);
+			Assert.Equal (Point.Empty, pos);
+			Assert.False (isReq);
+			Assert.Equal (0, (int)arg1);
+			Assert.Equal (Point.Empty, arg2);
+
+			// CSI
+			ClearAll ();
+			cki = new ConsoleKeyInfo [] {
+				new ConsoleKeyInfo ('\u001b', 0, false, false, false),
+				new ConsoleKeyInfo ('[', 0, false, false, false),
+				new ConsoleKeyInfo ('1', 0, false, false, false),
+				new ConsoleKeyInfo (';', 0, false, false, false),
+				new ConsoleKeyInfo ('2', 0, false, false, false),
+				new ConsoleKeyInfo ('R', 0, false, false, false)
+			};
+			expectedCki = new ConsoleKeyInfo ('\0', ConsoleKey.F3, true, false, false);
+			EscSeqUtils.DecodeEscSeq (escSeqReqProc, ref newConsoleKeyInfo, ref key, cki, ref mod, out c1Control, out code, out values, out terminating, out isKeyMouse, out mouseFlags, out pos, out isReq, ProcessContinuousButtonPressed);
+			Assert.Null (escSeqReqProc);
+			Assert.Equal (expectedCki, newConsoleKeyInfo);
+			Assert.Equal (ConsoleKey.F3, key);
+			Assert.Equal (ConsoleModifiers.Shift, mod);
+			Assert.Equal ("CSI", c1Control);
+			Assert.Null (code);
+			Assert.Equal (2, values.Length);
+			Assert.Equal ("1", values [0]);
+			Assert.Equal ("2", values [^1]);
+			Assert.Equal ("R", terminating);
+			Assert.False (isKeyMouse);
+			Assert.Equal (new List<MouseFlags> () { 0 }, mouseFlags);
+			Assert.Equal (Point.Empty, pos);
+			Assert.False (isReq);
+			Assert.Equal (0, (int)arg1);
+			Assert.Equal (Point.Empty, arg2);
+
+			ClearAll ();
+			cki = new ConsoleKeyInfo [] {
+				new ConsoleKeyInfo ('\u001b', 0, false, false, false),
+				new ConsoleKeyInfo ('[', 0, false, false, false),
+				new ConsoleKeyInfo ('1', 0, false, false, false),
+				new ConsoleKeyInfo (';', 0, false, false, false),
+				new ConsoleKeyInfo ('3', 0, false, false, false),
+				new ConsoleKeyInfo ('R', 0, false, false, false)
+			};
+			expectedCki = new ConsoleKeyInfo ('\0', ConsoleKey.F3, false, true, false);
+			EscSeqUtils.DecodeEscSeq (escSeqReqProc, ref newConsoleKeyInfo, ref key, cki, ref mod, out c1Control, out code, out values, out terminating, out isKeyMouse, out mouseFlags, out pos, out isReq, ProcessContinuousButtonPressed);
+			Assert.Null (escSeqReqProc);
+			Assert.Equal (expectedCki, newConsoleKeyInfo);
+			Assert.Equal (ConsoleKey.F3, key);
+			Assert.Equal (ConsoleModifiers.Alt, mod);
+			Assert.Equal ("CSI", c1Control);
+			Assert.Null (code);
+			Assert.Equal (2, values.Length);
+			Assert.Equal ("1", values [0]);
+			Assert.Equal ("3", values [^1]);
+			Assert.Equal ("R", terminating);
+			Assert.False (isKeyMouse);
+			Assert.Equal (new List<MouseFlags> () { 0 }, mouseFlags);
+			Assert.Equal (Point.Empty, pos);
+			Assert.False (isReq);
+			Assert.Equal (0, (int)arg1);
+			Assert.Equal (Point.Empty, arg2);
+
+			ClearAll ();
+			cki = new ConsoleKeyInfo [] {
+				new ConsoleKeyInfo ('\u001b', 0, false, false, false),
+				new ConsoleKeyInfo ('[', 0, false, false, false),
+				new ConsoleKeyInfo ('1', 0, false, false, false),
+				new ConsoleKeyInfo (';', 0, false, false, false),
+				new ConsoleKeyInfo ('4', 0, false, false, false),
+				new ConsoleKeyInfo ('R', 0, false, false, false)
+			};
+			expectedCki = new ConsoleKeyInfo ('\0', ConsoleKey.F3, true, true, false);
+			EscSeqUtils.DecodeEscSeq (escSeqReqProc, ref newConsoleKeyInfo, ref key, cki, ref mod, out c1Control, out code, out values, out terminating, out isKeyMouse, out mouseFlags, out pos, out isReq, ProcessContinuousButtonPressed);
+			Assert.Null (escSeqReqProc);
+			Assert.Equal (expectedCki, newConsoleKeyInfo);
+			Assert.Equal (ConsoleKey.F3, key);
+			Assert.Equal (ConsoleModifiers.Shift | ConsoleModifiers.Alt, mod);
+			Assert.Equal ("CSI", c1Control);
+			Assert.Null (code);
+			Assert.Equal (2, values.Length);
+			Assert.Equal ("1", values [0]);
+			Assert.Equal ("4", values [^1]);
+			Assert.Equal ("R", terminating);
+			Assert.False (isKeyMouse);
+			Assert.Equal (new List<MouseFlags> () { 0 }, mouseFlags);
+			Assert.Equal (Point.Empty, pos);
+			Assert.False (isReq);
+			Assert.Equal (0, (int)arg1);
+			Assert.Equal (Point.Empty, arg2);
+
+			ClearAll ();
+			cki = new ConsoleKeyInfo [] {
+				new ConsoleKeyInfo ('\u001b', 0, false, false, false),
+				new ConsoleKeyInfo ('[', 0, false, false, false),
+				new ConsoleKeyInfo ('1', 0, false, false, false),
+				new ConsoleKeyInfo (';', 0, false, false, false),
+				new ConsoleKeyInfo ('5', 0, false, false, false),
+				new ConsoleKeyInfo ('R', 0, false, false, false)
+			};
+			expectedCki = new ConsoleKeyInfo ('\0', ConsoleKey.F3, false, false, true);
+			EscSeqUtils.DecodeEscSeq (escSeqReqProc, ref newConsoleKeyInfo, ref key, cki, ref mod, out c1Control, out code, out values, out terminating, out isKeyMouse, out mouseFlags, out pos, out isReq, ProcessContinuousButtonPressed);
+			Assert.Null (escSeqReqProc);
+			Assert.Equal (expectedCki, newConsoleKeyInfo);
+			Assert.Equal (ConsoleKey.F3, key);
+			Assert.Equal (ConsoleModifiers.Control, mod);
+			Assert.Equal ("CSI", c1Control);
+			Assert.Null (code);
+			Assert.Equal (2, values.Length);
+			Assert.Equal ("1", values [0]);
+			Assert.Equal ("5", values [^1]);
+			Assert.Equal ("R", terminating);
+			Assert.False (isKeyMouse);
+			Assert.Equal (new List<MouseFlags> () { 0 }, mouseFlags);
+			Assert.Equal (Point.Empty, pos);
+			Assert.False (isReq);
+			Assert.Equal (0, (int)arg1);
+			Assert.Equal (Point.Empty, arg2);
+
+			ClearAll ();
+			cki = new ConsoleKeyInfo [] {
+				new ConsoleKeyInfo ('\u001b', 0, false, false, false),
+				new ConsoleKeyInfo ('[', 0, false, false, false),
+				new ConsoleKeyInfo ('1', 0, false, false, false),
+				new ConsoleKeyInfo (';', 0, false, false, false),
+				new ConsoleKeyInfo ('6', 0, false, false, false),
+				new ConsoleKeyInfo ('R', 0, false, false, false)
+			};
+			expectedCki = new ConsoleKeyInfo ('\0', ConsoleKey.F3, true, false, true);
+			EscSeqUtils.DecodeEscSeq (escSeqReqProc, ref newConsoleKeyInfo, ref key, cki, ref mod, out c1Control, out code, out values, out terminating, out isKeyMouse, out mouseFlags, out pos, out isReq, ProcessContinuousButtonPressed);
+			Assert.Null (escSeqReqProc);
+			Assert.Equal (expectedCki, newConsoleKeyInfo);
+			Assert.Equal (ConsoleKey.F3, key);
+			Assert.Equal (ConsoleModifiers.Shift | ConsoleModifiers.Control, mod);
+			Assert.Equal ("CSI", c1Control);
+			Assert.Null (code);
+			Assert.Equal (2, values.Length);
+			Assert.Equal ("1", values [0]);
+			Assert.Equal ("6", values [^1]);
+			Assert.Equal ("R", terminating);
+			Assert.False (isKeyMouse);
+			Assert.Equal (new List<MouseFlags> () { 0 }, mouseFlags);
+			Assert.Equal (Point.Empty, pos);
+			Assert.False (isReq);
+			Assert.Equal (0, (int)arg1);
+			Assert.Equal (Point.Empty, arg2);
+
+			ClearAll ();
+			cki = new ConsoleKeyInfo [] {
+				new ConsoleKeyInfo ('\u001b', 0, false, false, false),
+				new ConsoleKeyInfo ('[', 0, false, false, false),
+				new ConsoleKeyInfo ('1', 0, false, false, false),
+				new ConsoleKeyInfo (';', 0, false, false, false),
+				new ConsoleKeyInfo ('7', 0, false, false, false),
+				new ConsoleKeyInfo ('R', 0, false, false, false)
+			};
+			expectedCki = new ConsoleKeyInfo ('\0', ConsoleKey.F3, false, true, true);
+			EscSeqUtils.DecodeEscSeq (escSeqReqProc, ref newConsoleKeyInfo, ref key, cki, ref mod, out c1Control, out code, out values, out terminating, out isKeyMouse, out mouseFlags, out pos, out isReq, ProcessContinuousButtonPressed);
+			Assert.Null (escSeqReqProc);
+			Assert.Equal (expectedCki, newConsoleKeyInfo);
+			Assert.Equal (ConsoleKey.F3, key);
+			Assert.Equal (ConsoleModifiers.Alt | ConsoleModifiers.Control, mod);
+			Assert.Equal ("CSI", c1Control);
+			Assert.Null (code);
+			Assert.Equal (2, values.Length);
+			Assert.Equal ("1", values [0]);
+			Assert.Equal ("7", values [^1]);
+			Assert.Equal ("R", terminating);
+			Assert.False (isKeyMouse);
+			Assert.Equal (new List<MouseFlags> () { 0 }, mouseFlags);
+			Assert.Equal (Point.Empty, pos);
+			Assert.False (isReq);
+			Assert.Equal (0, (int)arg1);
+			Assert.Equal (Point.Empty, arg2);
+
+			ClearAll ();
+			cki = new ConsoleKeyInfo [] {
+				new ConsoleKeyInfo ('\u001b', 0, false, false, false),
+				new ConsoleKeyInfo ('[', 0, false, false, false),
+				new ConsoleKeyInfo ('1', 0, false, false, false),
+				new ConsoleKeyInfo (';', 0, false, false, false),
+				new ConsoleKeyInfo ('8', 0, false, false, false),
+				new ConsoleKeyInfo ('R', 0, false, false, false)
+			};
+			expectedCki = new ConsoleKeyInfo ('\0', ConsoleKey.F3, true, true, true);
+			EscSeqUtils.DecodeEscSeq (escSeqReqProc, ref newConsoleKeyInfo, ref key, cki, ref mod, out c1Control, out code, out values, out terminating, out isKeyMouse, out mouseFlags, out pos, out isReq, ProcessContinuousButtonPressed);
+			Assert.Null (escSeqReqProc);
+			Assert.Equal (expectedCki, newConsoleKeyInfo);
+			Assert.Equal (ConsoleKey.F3, key);
+			Assert.Equal (ConsoleModifiers.Shift | ConsoleModifiers.Alt | ConsoleModifiers.Control, mod);
+			Assert.Equal ("CSI", c1Control);
+			Assert.Null (code);
+			Assert.Equal (2, values.Length);
+			Assert.Equal ("1", values [0]);
+			Assert.Equal ("8", values [^1]);
+			Assert.Equal ("R", terminating);
+			Assert.False (isKeyMouse);
+			Assert.Equal (new List<MouseFlags> () { 0 }, mouseFlags);
+			Assert.Equal (Point.Empty, pos);
+			Assert.False (isReq);
+			Assert.Equal (0, (int)arg1);
+			Assert.Equal (Point.Empty, arg2);
+
+			ClearAll ();
+			cki = new ConsoleKeyInfo [] {
+				new ConsoleKeyInfo ('\u001b', 0, false, false, false),
+				new ConsoleKeyInfo ('[', 0, false, false, false),
+				new ConsoleKeyInfo ('<', 0, false, false, false),
+				new ConsoleKeyInfo ('0', 0, false, false, false),
+				new ConsoleKeyInfo (';', 0, false, false, false),
+				new ConsoleKeyInfo ('2', 0, false, false, false),
+				new ConsoleKeyInfo (';', 0, false, false, false),
+				new ConsoleKeyInfo ('3', 0, false, false, false),
+				new ConsoleKeyInfo ('M', 0, false, false, false)
+			};
+			expectedCki = default;
+			EscSeqUtils.DecodeEscSeq (escSeqReqProc, ref newConsoleKeyInfo, ref key, cki, ref mod, out c1Control, out code, out values, out terminating, out isKeyMouse, out mouseFlags, out pos, out isReq, ProcessContinuousButtonPressed);
+			Assert.Null (escSeqReqProc);
+			Assert.Equal (expectedCki, newConsoleKeyInfo);
+			Assert.Equal (0, (int)key);
+			Assert.Equal (0, (int)mod);
+			Assert.Equal ("CSI", c1Control);
+			Assert.Equal ("<", code);
+			Assert.Equal (3, values.Length);
+			Assert.Equal ("0", values [0]);
+			Assert.Equal ("2", values [1]);
+			Assert.Equal ("3", values [^1]);
+			Assert.Equal ("M", terminating);
+			Assert.True (isKeyMouse);
+			Assert.Equal (new List<MouseFlags> () { MouseFlags.Button1Pressed }, mouseFlags);
+			Assert.Equal (new Point (1, 2), pos);
+			Assert.False (isReq);
+			Assert.Equal (0, (int)arg1);
+			Assert.Equal (Point.Empty, arg2);
+
+			ClearAll ();
+			cki = new ConsoleKeyInfo [] {
+				new ConsoleKeyInfo ('\u001b', 0, false, false, false),
+				new ConsoleKeyInfo ('[', 0, false, false, false),
+				new ConsoleKeyInfo ('<', 0, false, false, false),
+				new ConsoleKeyInfo ('0', 0, false, false, false),
+				new ConsoleKeyInfo (';', 0, false, false, false),
+				new ConsoleKeyInfo ('2', 0, false, false, false),
+				new ConsoleKeyInfo (';', 0, false, false, false),
+				new ConsoleKeyInfo ('3', 0, false, false, false),
+				new ConsoleKeyInfo ('m', 0, false, false, false)
+			};
+			expectedCki = default;
+			EscSeqUtils.DecodeEscSeq (escSeqReqProc, ref newConsoleKeyInfo, ref key, cki, ref mod, out c1Control, out code, out values, out terminating, out isKeyMouse, out mouseFlags, out pos, out isReq, ProcessContinuousButtonPressed);
+			Assert.Null (escSeqReqProc);
+			Assert.Equal (expectedCki, newConsoleKeyInfo);
+			Assert.Equal (0, (int)key);
+			Assert.Equal (0, (int)mod);
+			Assert.Equal ("CSI", c1Control);
+			Assert.Equal ("<", code);
+			Assert.Equal (3, values.Length);
+			Assert.Equal ("0", values [0]);
+			Assert.Equal ("2", values [1]);
+			Assert.Equal ("3", values [^1]);
+			Assert.Equal ("m", terminating);
+			Assert.True (isKeyMouse);
+			Assert.Equal (2, mouseFlags.Count);
+			Assert.Equal (new List<MouseFlags> () { MouseFlags.Button1Released, MouseFlags.Button1Clicked }, mouseFlags);
+			Assert.Equal (new Point (1, 2), pos);
+			Assert.False (isReq);
+			Assert.Equal (0, (int)arg1);
+			Assert.Equal (Point.Empty, arg2);
+
+			ClearAll ();
+			cki = new ConsoleKeyInfo [] {
+				new ConsoleKeyInfo ('\u001b', 0, false, false, false),
+				new ConsoleKeyInfo ('[', 0, false, false, false),
+				new ConsoleKeyInfo ('<', 0, false, false, false),
+				new ConsoleKeyInfo ('0', 0, false, false, false),
+				new ConsoleKeyInfo (';', 0, false, false, false),
+				new ConsoleKeyInfo ('2', 0, false, false, false),
+				new ConsoleKeyInfo (';', 0, false, false, false),
+				new ConsoleKeyInfo ('3', 0, false, false, false),
+				new ConsoleKeyInfo ('M', 0, false, false, false)
+			};
+			expectedCki = default;
+			EscSeqUtils.DecodeEscSeq (escSeqReqProc, ref newConsoleKeyInfo, ref key, cki, ref mod, out c1Control, out code, out values, out terminating, out isKeyMouse, out mouseFlags, out pos, out isReq, ProcessContinuousButtonPressed);
+			Assert.Null (escSeqReqProc);
+			Assert.Equal (expectedCki, newConsoleKeyInfo);
+			Assert.Equal (0, (int)key);
+			Assert.Equal (0, (int)mod);
+			Assert.Equal ("CSI", c1Control);
+			Assert.Equal ("<", code);
+			Assert.Equal (3, values.Length);
+			Assert.Equal ("0", values [0]);
+			Assert.Equal ("2", values [1]);
+			Assert.Equal ("3", values [^1]);
+			Assert.Equal ("M", terminating);
+			Assert.True (isKeyMouse);
+			Assert.Equal (new List<MouseFlags> () { MouseFlags.Button1DoubleClicked }, mouseFlags);
+			Assert.Equal (new Point (1, 2), pos);
+			Assert.False (isReq);
+
+			ClearAll ();
+			cki = new ConsoleKeyInfo [] {
+				new ConsoleKeyInfo ('\u001b', 0, false, false, false),
+				new ConsoleKeyInfo ('[', 0, false, false, false),
+				new ConsoleKeyInfo ('<', 0, false, false, false),
+				new ConsoleKeyInfo ('0', 0, false, false, false),
+				new ConsoleKeyInfo (';', 0, false, false, false),
+				new ConsoleKeyInfo ('2', 0, false, false, false),
+				new ConsoleKeyInfo (';', 0, false, false, false),
+				new ConsoleKeyInfo ('3', 0, false, false, false),
+				new ConsoleKeyInfo ('M', 0, false, false, false)
+			};
+			expectedCki = default;
+			EscSeqUtils.DecodeEscSeq (escSeqReqProc, ref newConsoleKeyInfo, ref key, cki, ref mod, out c1Control, out code, out values, out terminating, out isKeyMouse, out mouseFlags, out pos, out isReq, ProcessContinuousButtonPressed);
+			Assert.Null (escSeqReqProc);
+			Assert.Equal (expectedCki, newConsoleKeyInfo);
+			Assert.Equal (0, (int)key);
+			Assert.Equal (0, (int)mod);
+			Assert.Equal ("CSI", c1Control);
+			Assert.Equal ("<", code);
+			Assert.Equal (3, values.Length);
+			Assert.Equal ("0", values [0]);
+			Assert.Equal ("2", values [1]);
+			Assert.Equal ("3", values [^1]);
+			Assert.Equal ("M", terminating);
+			Assert.True (isKeyMouse);
+			Assert.Equal (new List<MouseFlags> () { MouseFlags.Button1TripleClicked }, mouseFlags);
+			Assert.Equal (new Point (1, 2), pos);
+			Assert.False (isReq);
+
+			var view = new View () {
+				Width = Dim.Fill (),
+				Height = Dim.Fill (),
+				WantContinuousButtonPressed = true
+			};
+			Application.Top.Add (view);
+			Application.Begin (Application.Top);
+
+			ReflectionTools.InvokePrivate (
+				typeof (Application),
+				"ProcessMouseEvent",
+				new MouseEvent () {
+					X = 0,
+					Y = 0,
+					Flags = 0
+				});
+
+			ClearAll ();
+			cki = new ConsoleKeyInfo [] {
+				new ConsoleKeyInfo ('\u001b', 0, false, false, false),
+				new ConsoleKeyInfo ('[', 0, false, false, false),
+				new ConsoleKeyInfo ('<', 0, false, false, false),
+				new ConsoleKeyInfo ('0', 0, false, false, false),
+				new ConsoleKeyInfo (';', 0, false, false, false),
+				new ConsoleKeyInfo ('2', 0, false, false, false),
+				new ConsoleKeyInfo (';', 0, false, false, false),
+				new ConsoleKeyInfo ('3', 0, false, false, false),
+				new ConsoleKeyInfo ('M', 0, false, false, false)
+			};
+			expectedCki = default;
+			EscSeqUtils.DecodeEscSeq (escSeqReqProc, ref newConsoleKeyInfo, ref key, cki, ref mod, out c1Control, out code, out values, out terminating, out isKeyMouse, out mouseFlags, out pos, out isReq, ProcessContinuousButtonPressed);
+			Assert.Null (escSeqReqProc);
+			Assert.Equal (expectedCki, newConsoleKeyInfo);
+			Assert.Equal (0, (int)key);
+			Assert.Equal (0, (int)mod);
+			Assert.Equal ("CSI", c1Control);
+			Assert.Equal ("<", code);
+			Assert.Equal (3, values.Length);
+			Assert.Equal ("0", values [0]);
+			Assert.Equal ("2", values [1]);
+			Assert.Equal ("3", values [^1]);
+			Assert.Equal ("M", terminating);
+			Assert.True (isKeyMouse);
+			Assert.Equal (new List<MouseFlags> () { MouseFlags.Button1Pressed }, mouseFlags);
+			Assert.Equal (new Point (1, 2), pos);
+			Assert.False (isReq);
+
+			Application.Iteration += () => {
+				if (actionStarted) {
+					// set Application.WantContinuousButtonPressedView to null
+					view.WantContinuousButtonPressed = false;
+					ReflectionTools.InvokePrivate (
+						typeof (Application),
+						"ProcessMouseEvent",
+						new MouseEvent () {
+							X = 0,
+							Y = 0,
+							Flags = 0
+						});
+
+					Application.RequestStop ();
+				}
+			};
+
+			Application.Run ();
+
+			Assert.Null (Application.WantContinuousButtonPressedView);
+
+			Assert.Equal (MouseFlags.Button1Pressed, arg1);
+			Assert.Equal (new Point (1, 2), arg2);
+
+			ClearAll ();
+			cki = new ConsoleKeyInfo [] {
+				new ConsoleKeyInfo ('\u001b', 0, false, false, false),
+				new ConsoleKeyInfo ('[', 0, false, false, false),
+				new ConsoleKeyInfo ('<', 0, false, false, false),
+				new ConsoleKeyInfo ('0', 0, false, false, false),
+				new ConsoleKeyInfo (';', 0, false, false, false),
+				new ConsoleKeyInfo ('2', 0, false, false, false),
+				new ConsoleKeyInfo (';', 0, false, false, false),
+				new ConsoleKeyInfo ('3', 0, false, false, false),
+				new ConsoleKeyInfo ('m', 0, false, false, false)
+			};
+			expectedCki = default;
+			EscSeqUtils.DecodeEscSeq (escSeqReqProc, ref newConsoleKeyInfo, ref key, cki, ref mod, out c1Control, out code, out values, out terminating, out isKeyMouse, out mouseFlags, out pos, out isReq, ProcessContinuousButtonPressed);
+			Assert.Null (escSeqReqProc);
+			Assert.Equal (expectedCki, newConsoleKeyInfo);
+			Assert.Equal (0, (int)key);
+			Assert.Equal (0, (int)mod);
+			Assert.Equal ("CSI", c1Control);
+			Assert.Equal ("<", code);
+			Assert.Equal (3, values.Length);
+			Assert.Equal ("0", values [0]);
+			Assert.Equal ("2", values [1]);
+			Assert.Equal ("3", values [^1]);
+			Assert.Equal ("m", terminating);
+			Assert.True (isKeyMouse);
+			Assert.Equal (new List<MouseFlags> () { MouseFlags.Button1Released }, mouseFlags);
+			Assert.Equal (new Point (1, 2), pos);
+			Assert.False (isReq);
+			Assert.Equal (0, (int)arg1);
+			Assert.Equal (Point.Empty, arg2);
+
+			ClearAll ();
+
+			Assert.Null (escSeqReqProc);
+			escSeqReqProc = new EscSeqReqProc ();
+			escSeqReqProc.Add ("t");
+
+			cki = new ConsoleKeyInfo [] {
+				new ConsoleKeyInfo ('\u001b', 0, false, false, false),
+				new ConsoleKeyInfo ('[', 0, false, false, false),
+				new ConsoleKeyInfo ('8', 0, false, false, false),
+				new ConsoleKeyInfo (';', 0, false, false, false),
+				new ConsoleKeyInfo ('1', 0, false, false, false),
+				new ConsoleKeyInfo ('0', 0, false, false, false),
+				new ConsoleKeyInfo (';', 0, false, false, false),
+				new ConsoleKeyInfo ('2', 0, false, false, false),
+				new ConsoleKeyInfo ('0', 0, false, false, false),
+				new ConsoleKeyInfo ('t', 0, false, false, false)
+			};
+			expectedCki = default;
+			Assert.Single (escSeqReqProc.EscSeqReqStats);
+			Assert.Equal ("t", escSeqReqProc.EscSeqReqStats [^1].Terminating);
+			EscSeqUtils.DecodeEscSeq (escSeqReqProc, ref newConsoleKeyInfo, ref key, cki, ref mod, out c1Control, out code, out values, out terminating, out isKeyMouse, out mouseFlags, out pos, out isReq, ProcessContinuousButtonPressed);
+			Assert.Empty (escSeqReqProc.EscSeqReqStats);
+			Assert.Equal (expectedCki, newConsoleKeyInfo);
+			Assert.Equal (0, (int)key);
+			Assert.Equal (0, (int)mod);
+			Assert.Equal ("CSI", c1Control);
+			Assert.Null (code);
+			Assert.Equal (3, values.Length);
+			Assert.Equal ("8", values [0]);
+			Assert.Equal ("10", values [1]);
+			Assert.Equal ("20", values [^1]);
+			Assert.Equal ("t", terminating);
+			Assert.False (isKeyMouse);
+			Assert.Equal (new List<MouseFlags> () { 0 }, mouseFlags);
+			Assert.Equal (Point.Empty, pos);
+			Assert.True (isReq);
+			Assert.Equal (0, (int)arg1);
+			Assert.Equal (Point.Empty, arg2);
+		}
+
+		private void ClearAll ()
+		{
+			escSeqReqProc = default;
+			newConsoleKeyInfo = default;
+			key = default;
+			cki = default;
+			mod = default;
+			c1Control = default;
+			code = default;
+			terminating = default;
+			values = default;
+			isKeyMouse = default;
+			isReq = default;
+			mouseFlags = default;
+			pos = default;
+			arg1 = default;
+			arg2 = default;
+		}
+
+		private void ProcessContinuousButtonPressed (MouseFlags arg1, Point arg2)
+		{
+			this.arg1 = arg1;
+			this.arg2 = arg2;
+			actionStarted = true;
+		}
+
+		[Fact]
+		public void GetEscapeResult_Tests ()
+		{
+			char [] kChars = new char [] { '\u001b', '[', '5', ';', '1', '0', 'r' };
+			(c1Control, code, values, terminating) = EscSeqUtils.GetEscapeResult (kChars);
+			Assert.Equal ("CSI", c1Control);
+			Assert.Null (code);
+			Assert.Equal (2, values.Length);
+			Assert.Equal ("5", values [0]);
+			Assert.Equal ("10", values [^1]);
+			Assert.Equal ("r", terminating);
+		}
+
+		[Fact]
+		public void GetC1ControlChar_Tests ()
+		{
+			Assert.Equal ("IND", EscSeqUtils.GetC1ControlChar ('D'));
+			Assert.Equal ("NEL", EscSeqUtils.GetC1ControlChar ('E'));
+			Assert.Equal ("HTS", EscSeqUtils.GetC1ControlChar ('H'));
+			Assert.Equal ("RI", EscSeqUtils.GetC1ControlChar ('M'));
+			Assert.Equal ("SS2", EscSeqUtils.GetC1ControlChar ('N'));
+			Assert.Equal ("SS3", EscSeqUtils.GetC1ControlChar ('O'));
+			Assert.Equal ("DCS", EscSeqUtils.GetC1ControlChar ('P'));
+			Assert.Equal ("SPA", EscSeqUtils.GetC1ControlChar ('V'));
+			Assert.Equal ("EPA", EscSeqUtils.GetC1ControlChar ('W'));
+			Assert.Equal ("SOS", EscSeqUtils.GetC1ControlChar ('X'));
+			Assert.Equal ("DECID", EscSeqUtils.GetC1ControlChar ('Z'));
+			Assert.Equal ("CSI", EscSeqUtils.GetC1ControlChar ('['));
+			Assert.Equal ("ST", EscSeqUtils.GetC1ControlChar ('\\'));
+			Assert.Equal ("OSC", EscSeqUtils.GetC1ControlChar (']'));
+			Assert.Equal ("PM", EscSeqUtils.GetC1ControlChar ('^'));
+			Assert.Equal ("APC", EscSeqUtils.GetC1ControlChar ('_'));
+			Assert.Equal ("", EscSeqUtils.GetC1ControlChar ('\0'));
+		}
+
+		[Fact]
+		public void GetConsoleModifiers_Tests ()
+		{
+			Assert.Equal (ConsoleModifiers.Shift, EscSeqUtils.GetConsoleModifiers ("2"));
+			Assert.Equal (ConsoleModifiers.Alt, EscSeqUtils.GetConsoleModifiers ("3"));
+			Assert.Equal (ConsoleModifiers.Shift | ConsoleModifiers.Alt, EscSeqUtils.GetConsoleModifiers ("4"));
+			Assert.Equal (ConsoleModifiers.Control, EscSeqUtils.GetConsoleModifiers ("5"));
+			Assert.Equal (ConsoleModifiers.Shift | ConsoleModifiers.Control, EscSeqUtils.GetConsoleModifiers ("6"));
+			Assert.Equal (ConsoleModifiers.Alt | ConsoleModifiers.Control, EscSeqUtils.GetConsoleModifiers ("7"));
+			Assert.Equal (ConsoleModifiers.Shift | ConsoleModifiers.Alt | ConsoleModifiers.Control, EscSeqUtils.GetConsoleModifiers ("8"));
+			Assert.Equal (0, (int)EscSeqUtils.GetConsoleModifiers (""));
+		}
+
+		[Fact]
+		public void GetConsoleKey_Tests ()
+		{
+			ConsoleModifiers mod = 0;
+			Assert.Equal (ConsoleKey.UpArrow, EscSeqUtils.GetConsoleKey ('A', "", ref mod));
+			Assert.Equal (ConsoleKey.DownArrow, EscSeqUtils.GetConsoleKey ('B', "", ref mod));
+			Assert.Equal (key = ConsoleKey.RightArrow, EscSeqUtils.GetConsoleKey ('C', "", ref mod));
+			Assert.Equal (ConsoleKey.LeftArrow, EscSeqUtils.GetConsoleKey ('D', "", ref mod));
+			Assert.Equal (ConsoleKey.End, EscSeqUtils.GetConsoleKey ('F', "", ref mod));
+			Assert.Equal (ConsoleKey.Home, EscSeqUtils.GetConsoleKey ('H', "", ref mod));
+			Assert.Equal (ConsoleKey.F1, EscSeqUtils.GetConsoleKey ('P', "", ref mod));
+			Assert.Equal (ConsoleKey.F2, EscSeqUtils.GetConsoleKey ('Q', "", ref mod));
+			Assert.Equal (ConsoleKey.F3, EscSeqUtils.GetConsoleKey ('R', "", ref mod));
+			Assert.Equal (ConsoleKey.F4, EscSeqUtils.GetConsoleKey ('S', "", ref mod));
+			Assert.Equal (ConsoleKey.Tab, EscSeqUtils.GetConsoleKey ('Z', "", ref mod));
+			Assert.Equal (ConsoleModifiers.Shift, mod);
+			Assert.Equal (0, (int)EscSeqUtils.GetConsoleKey ('\0', "", ref mod));
+			Assert.Equal (ConsoleKey.Insert, EscSeqUtils.GetConsoleKey ('~', "2", ref mod));
+			Assert.Equal (ConsoleKey.Delete, EscSeqUtils.GetConsoleKey ('~', "3", ref mod));
+			Assert.Equal (ConsoleKey.PageUp, EscSeqUtils.GetConsoleKey ('~', "5", ref mod));
+			Assert.Equal (ConsoleKey.PageDown, EscSeqUtils.GetConsoleKey ('~', "6", ref mod));
+			Assert.Equal (ConsoleKey.F5, EscSeqUtils.GetConsoleKey ('~', "15", ref mod));
+			Assert.Equal (ConsoleKey.F6, EscSeqUtils.GetConsoleKey ('~', "17", ref mod));
+			Assert.Equal (ConsoleKey.F7, EscSeqUtils.GetConsoleKey ('~', "18", ref mod));
+			Assert.Equal (ConsoleKey.F8, EscSeqUtils.GetConsoleKey ('~', "19", ref mod));
+			Assert.Equal (ConsoleKey.F9, EscSeqUtils.GetConsoleKey ('~', "20", ref mod));
+			Assert.Equal (ConsoleKey.F10, EscSeqUtils.GetConsoleKey ('~', "21", ref mod));
+			Assert.Equal (ConsoleKey.F11, EscSeqUtils.GetConsoleKey ('~', "23", ref mod));
+			Assert.Equal (ConsoleKey.F12, EscSeqUtils.GetConsoleKey ('~', "24", ref mod));
+			Assert.Equal (0, (int)EscSeqUtils.GetConsoleKey ('~', "", ref mod));
+		}
+
+		[Fact]
+		public void GetKeyCharArray_Tests ()
+		{
+			var cki = new ConsoleKeyInfo [] {
+				new ConsoleKeyInfo('\u001b', 0, false, false, false),
+				new ConsoleKeyInfo('[', 0, false, false, false),
+				new ConsoleKeyInfo('5', 0, false, false, false),
+				new ConsoleKeyInfo(';', 0, false, false, false),
+				new ConsoleKeyInfo('1', 0, false, false, false),
+				new ConsoleKeyInfo('0', 0, false, false, false),
+				new ConsoleKeyInfo('r', 0, false, false, false),
+			};
+
+			Assert.Equal (new char [] { '\u001b', '[', '5', ';', '1', '0', 'r' }, EscSeqUtils.GetKeyCharArray (cki));
+		}
+
+		[Fact, AutoInitShutdown]
+		public void GetMouse_Tests ()
+		{
+			var cki = new ConsoleKeyInfo [] {
+				new ConsoleKeyInfo ('\u001b', 0, false, false, false),
+				new ConsoleKeyInfo ('[', 0, false, false, false),
+				new ConsoleKeyInfo ('<', 0, false, false, false),
+				new ConsoleKeyInfo ('0', 0, false, false, false),
+				new ConsoleKeyInfo (';', 0, false, false, false),
+				new ConsoleKeyInfo ('2', 0, false, false, false),
+				new ConsoleKeyInfo (';', 0, false, false, false),
+				new ConsoleKeyInfo ('3', 0, false, false, false),
+				new ConsoleKeyInfo ('M', 0, false, false, false)
+			};
+			EscSeqUtils.GetMouse (cki, out List<MouseFlags> mouseFlags, out Point pos, ProcessContinuousButtonPressed);
+			Assert.Equal (new List<MouseFlags> () { MouseFlags.Button1Pressed }, mouseFlags);
+			Assert.Equal (new Point (1, 2), pos);
+
+			cki = new ConsoleKeyInfo [] {
+				new ConsoleKeyInfo ('\u001b', 0, false, false, false),
+				new ConsoleKeyInfo ('[', 0, false, false, false),
+				new ConsoleKeyInfo ('<', 0, false, false, false),
+				new ConsoleKeyInfo ('0', 0, false, false, false),
+				new ConsoleKeyInfo (';', 0, false, false, false),
+				new ConsoleKeyInfo ('2', 0, false, false, false),
+				new ConsoleKeyInfo (';', 0, false, false, false),
+				new ConsoleKeyInfo ('3', 0, false, false, false),
+				new ConsoleKeyInfo ('m', 0, false, false, false)
+			};
+			EscSeqUtils.GetMouse (cki, out mouseFlags, out pos, ProcessContinuousButtonPressed);
+			Assert.Equal (2, mouseFlags.Count);
+			Assert.Equal (new List<MouseFlags> () { MouseFlags.Button1Released, MouseFlags.Button1Clicked }, mouseFlags);
+			Assert.Equal (new Point (1, 2), pos);
+
+			cki = new ConsoleKeyInfo [] {
+				new ConsoleKeyInfo ('\u001b', 0, false, false, false),
+				new ConsoleKeyInfo ('[', 0, false, false, false),
+				new ConsoleKeyInfo ('<', 0, false, false, false),
+				new ConsoleKeyInfo ('0', 0, false, false, false),
+				new ConsoleKeyInfo (';', 0, false, false, false),
+				new ConsoleKeyInfo ('2', 0, false, false, false),
+				new ConsoleKeyInfo (';', 0, false, false, false),
+				new ConsoleKeyInfo ('3', 0, false, false, false),
+				new ConsoleKeyInfo ('M', 0, false, false, false)
+			};
+			EscSeqUtils.GetMouse (cki, out mouseFlags, out pos, ProcessContinuousButtonPressed);
+			Assert.Equal (new List<MouseFlags> () { MouseFlags.Button1DoubleClicked }, mouseFlags);
+			Assert.Equal (new Point (1, 2), pos);
+
+			cki = new ConsoleKeyInfo [] {
+				new ConsoleKeyInfo ('\u001b', 0, false, false, false),
+				new ConsoleKeyInfo ('[', 0, false, false, false),
+				new ConsoleKeyInfo ('<', 0, false, false, false),
+				new ConsoleKeyInfo ('0', 0, false, false, false),
+				new ConsoleKeyInfo (';', 0, false, false, false),
+				new ConsoleKeyInfo ('2', 0, false, false, false),
+				new ConsoleKeyInfo (';', 0, false, false, false),
+				new ConsoleKeyInfo ('3', 0, false, false, false),
+				new ConsoleKeyInfo ('M', 0, false, false, false)
+			};
+			EscSeqUtils.GetMouse (cki, out mouseFlags, out pos, ProcessContinuousButtonPressed);
+			Assert.Equal (new List<MouseFlags> () { MouseFlags.Button1TripleClicked }, mouseFlags);
+			Assert.Equal (new Point (1, 2), pos);
+
+			cki = new ConsoleKeyInfo [] {
+				new ConsoleKeyInfo ('\u001b', 0, false, false, false),
+				new ConsoleKeyInfo ('[', 0, false, false, false),
+				new ConsoleKeyInfo ('<', 0, false, false, false),
+				new ConsoleKeyInfo ('0', 0, false, false, false),
+				new ConsoleKeyInfo (';', 0, false, false, false),
+				new ConsoleKeyInfo ('2', 0, false, false, false),
+				new ConsoleKeyInfo (';', 0, false, false, false),
+				new ConsoleKeyInfo ('3', 0, false, false, false),
+				new ConsoleKeyInfo ('m', 0, false, false, false)
+			};
+			EscSeqUtils.GetMouse (cki, out mouseFlags, out pos, ProcessContinuousButtonPressed);
+			Assert.Equal (new List<MouseFlags> () { MouseFlags.Button1Released }, mouseFlags);
+			Assert.Equal (new Point (1, 2), pos);
+		}
+
+		[Fact]
+		public void GetParentProcess_Tests ()
+		{
+			if (RuntimeInformation.IsOSPlatform (OSPlatform.Windows)) {
+				Assert.NotNull (EscSeqUtils.GetParentProcess (Process.GetCurrentProcess ()));
+			} else {
+				Assert.Null (EscSeqUtils.GetParentProcess (Process.GetCurrentProcess ()));
+			}
+		}
+	}
+}

UnitTests/Drivers/ConsoleDriverTests.cs

@@ -171,7 +171,7 @@ namespace Terminal.Gui.DriverTests {
 
 			// MockDriver will still be 120x40
 			wasTerminalResized = false;
-			Application.HeightAsBuffer = true;
+			Application.EnableConsoleScrolling = true;
 			driver.SetWindowSize (40, 20);
 			Assert.Equal (120, Application.Driver.Cols);
 			Assert.Equal (40, Application.Driver.Rows);
@@ -186,12 +186,12 @@ namespace Terminal.Gui.DriverTests {
 
 		[Theory]
 		[InlineData (typeof (FakeDriver))]
-		public void HeightAsBuffer_Is_False_Left_And_Top_Is_Always_Zero (Type driverType)
+		public void EnableConsoleScrolling_Is_False_Left_And_Top_Is_Always_Zero (Type driverType)
 		{
 			var driver = (FakeDriver)Activator.CreateInstance (driverType);
 			Application.Init (driver);
 
-			Assert.False (Application.HeightAsBuffer);
+			Assert.False (Application.EnableConsoleScrolling);
 			Assert.Equal (0, Console.WindowLeft);
 			Assert.Equal (0, Console.WindowTop);
 
@@ -204,13 +204,13 @@ namespace Terminal.Gui.DriverTests {
 
 		[Theory]
 		[InlineData (typeof (FakeDriver))]
-		public void HeightAsBuffer_Is_True_Left_Cannot_Be_Greater_Than_WindowWidth (Type driverType)
+		public void EnableConsoleScrolling_Is_True_Left_Cannot_Be_Greater_Than_WindowWidth (Type driverType)
 		{
 			var driver = (FakeDriver)Activator.CreateInstance (driverType);
 			Application.Init (driver);
 
-			Application.HeightAsBuffer = true;
-			Assert.True (Application.HeightAsBuffer);
+			Application.EnableConsoleScrolling = true;
+			Assert.True (Application.EnableConsoleScrolling);
 
 			driver.SetWindowPosition (81, 25);
 			Assert.Equal (0, Console.WindowLeft);
@@ -221,13 +221,13 @@ namespace Terminal.Gui.DriverTests {
 
 		[Theory]
 		[InlineData (typeof (FakeDriver))]
-		public void HeightAsBuffer_Is_True_Left_Cannot_Be_Greater_Than_BufferWidth_Minus_WindowWidth (Type driverType)
+		public void EnableConsoleScrolling_Is_True_Left_Cannot_Be_Greater_Than_BufferWidth_Minus_WindowWidth (Type driverType)
 		{
 			var driver = (FakeDriver)Activator.CreateInstance (driverType);
 			Application.Init (driver);
 
-			Application.HeightAsBuffer = true;
-			Assert.True (Application.HeightAsBuffer);
+			Application.EnableConsoleScrolling = true;
+			Assert.True (Application.EnableConsoleScrolling);
 
 			driver.SetWindowPosition (81, 25);
 			Assert.Equal (0, Console.WindowLeft);
@@ -261,13 +261,13 @@ namespace Terminal.Gui.DriverTests {
 
 		[Theory]
 		[InlineData (typeof (FakeDriver))]
-		public void HeightAsBuffer_Is_True_Top_Cannot_Be_Greater_Than_WindowHeight (Type driverType)
+		public void EnableConsoleScrolling_Is_True_Top_Cannot_Be_Greater_Than_WindowHeight (Type driverType)
 		{
 			var driver = (FakeDriver)Activator.CreateInstance (driverType);
 			Application.Init (driver);
 
-			Application.HeightAsBuffer = true;
-			Assert.True (Application.HeightAsBuffer);
+			Application.EnableConsoleScrolling = true;
+			Assert.True (Application.EnableConsoleScrolling);
 
 			driver.SetWindowPosition (80, 26);
 			Assert.Equal (0, Console.WindowLeft);
@@ -278,13 +278,13 @@ namespace Terminal.Gui.DriverTests {
 
 		[Theory]
 		[InlineData (typeof (FakeDriver))]
-		public void HeightAsBuffer_Is_True_Top_Cannot_Be_Greater_Than_BufferHeight_Minus_WindowHeight (Type driverType)
+		public void EnableConsoleScrolling_Is_True_Top_Cannot_Be_Greater_Than_BufferHeight_Minus_WindowHeight (Type driverType)
 		{
 			var driver = (FakeDriver)Activator.CreateInstance (driverType);
 			Application.Init (driver);
 
-			Application.HeightAsBuffer = true;
-			Assert.True (Application.HeightAsBuffer);
+			Application.EnableConsoleScrolling = true;
+			Assert.True (Application.EnableConsoleScrolling);
 
 			driver.SetWindowPosition (80, 26);
 			Assert.Equal (0, Console.WindowLeft);

UnitTests/UnitTests.csproj

@@ -21,8 +21,8 @@
     <DefineConstants>TRACE;DEBUG_IDISPOSABLE</DefineConstants>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.1" />
-    <PackageReference Include="ReportGenerator" Version="5.1.12" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.5.0" />
+    <PackageReference Include="ReportGenerator" Version="5.1.17" />
     <PackageReference Include="System.Collections" Version="4.3.0" />
     <PackageReference Include="xunit" Version="2.4.2" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">