// Disgusting language hack to make it easier to read a sequence of keys.

using _ = Keys;

[TestClass]

public class UnitTest

{

static UnitTest()

{

var iss = InitialSessionState.CreateDefault2();

var rs = RunspaceFactory.CreateRunspace(iss);

rs.Open();

Runspace.DefaultRunspace = rs;

for (var i = 'a'; i <= 'z'; i++)

{

CharToKeyInfo[i] = new ConsoleKeyInfo(i, ConsoleKey.A + 'a' - i, false, false, false);

}

for (var i = 'A'; i <= 'Z'; i++)

{

CharToKeyInfo[i] = new ConsoleKeyInfo(i, ConsoleKey.A + 'A' - i, true, false, false);

}

for (var i = '0'; i <= '9'; i++)

{

CharToKeyInfo[i] = new ConsoleKeyInfo(i, ConsoleKey.D0 + '0' - i, false, false, false);

}

CharToKeyInfo['{'] = _.LCurly;

CharToKeyInfo['}'] = _.RCurly;

CharToKeyInfo['('] = _.LParen;

CharToKeyInfo[')'] = _.RParen;

CharToKeyInfo['['] = _.LBracket;

CharToKeyInfo[']'] = _.RBracket;

CharToKeyInfo[' '] = _.Space;

CharToKeyInfo['$'] = _.Dollar;

CharToKeyInfo['#'] = _.Pound;

CharToKeyInfo['<'] = _.LessThan;

CharToKeyInfo['>'] = _.GreaterThan;

CharToKeyInfo['+'] = _.Plus;

CharToKeyInfo['-'] = _.Minus;

CharToKeyInfo['_'] = _.Underbar;

CharToKeyInfo['|'] = _.Pipe;

CharToKeyInfo[';'] = _.Semicolon;

CharToKeyInfo['"'] = _.DQuote;

CharToKeyInfo['\''] = _.SQuote;

CharToKeyInfo['\n'] = new ConsoleKeyInfo('\r', ConsoleKey.Enter, false, false, false);

CharToKeyInfo['\r'] = new ConsoleKeyInfo('\r', ConsoleKey.Enter, false, false, false);

}

private enum KeyMode

{

Cmd,

Emacs,

#if FALSE

Vi

#endif

};

// These colors are random - we just use these colors instead of the defaults

// so the tests aren't sensitive to tweaks to the default colors.

private static readonly ConsoleColor[] ForegroundColors = new []

{

/*None*/ Console.ForegroundColor,

/*Comment*/ ConsoleColor.Blue,

/*Keyword*/ ConsoleColor.Cyan,

/*String*/ ConsoleColor.Gray,

/*Operator*/ ConsoleColor.Green,

/*Variable*/ ConsoleColor.Magenta,

/*Command*/ ConsoleColor.Red,

/*Parameter*/ ConsoleColor.White,

/*Type*/ ConsoleColor.Yellow,

/*Number*/ ConsoleColor.DarkBlue,

};

private static readonly ConsoleColor[] BackgroundColors = new[]

{

/*None*/ Console.BackgroundColor,

/*Comment*/ ConsoleColor.DarkBlue,

/*Keyword*/ ConsoleColor.DarkCyan,

/*String*/ ConsoleColor.DarkGray,

/*Operator*/ ConsoleColor.DarkGreen,

/*Variable*/ ConsoleColor.DarkMagenta,

/*Command*/ ConsoleColor.DarkRed,

/*Parameter*/ ConsoleColor.DarkYellow,

/*Type*/ ConsoleColor.Black,

/*Number*/ ConsoleColor.Gray,

};

static Dictionary<char, ConsoleKeyInfo> CharToKeyInfo = new Dictionary<char, ConsoleKeyInfo>();

class KeyHandler

{

public KeyHandler(ConsoleKeyInfo key, Action handler)

{

this.Key = key;

this.Handler = handler;

}

public ConsoleKeyInfo Key { get; private set; }

public Action Handler { get; private set; }

}

class KeyWithValidation

{

public KeyWithValidation(ConsoleKeyInfo key, Action validator = null)

{

this.Key = key;

this.Validator = validator;

}

public ConsoleKeyInfo Key { get; set; }

public Action Validator { get; set; }

}

class CancelReadLineException : Exception

{

public static void Throw()

{

throw new CancelReadLineException();

}

}

private void AssertCursorLeftTopIs(int left, int top)

{

AssertCursorLeftIs(left);

AssertCursorTopIs(top);

}

private void AssertCursorLeftIs(int expected)

{

Assert.AreEqual(expected, Console.CursorLeft);

}

private void AssertCursorTopIs(int expected)

{

Assert.AreEqual(expected, Console.CursorTop);

}

private void AssertLineIs(string expected)

{

string input;

int unused;

PSConsoleReadLine.GetBufferState(out input, out unused);

Assert.AreEqual(expected, input);

}

private class NextLineToken { }

static NextLineToken NextLine = new NextLineToken();

private CHAR_INFO[] CreateCharInfoBuffer(params object[] items)

{

var result = new List<CHAR_INFO>();

var fg = Console.ForegroundColor;

var bg = Console.BackgroundColor;

foreach (var i in items)

{

var item = i;

if (item is char)

{

result.Add(new CHAR_INFO((char)item, fg, bg));

continue;

}

if (item is NextLineToken)

{

item = new string(' ', Console.BufferWidth - (result.Count % Console.BufferWidth));

fg = Console.ForegroundColor;

bg = Console.BackgroundColor;

// Fallthrough to string case.

}

var str = item as string;

if (str != null)

{

result.AddRange(str.Select(c => new CHAR_INFO(c, fg, bg)));

continue;

}

if (item is TokenClassification)

{

fg = ForegroundColors[(int)(TokenClassification)item];

bg = BackgroundColors[(int)(TokenClassification)item];

continue;

}

var tuple = item as Tuple<ConsoleColor, ConsoleColor>;

if (tuple != null)

{

fg = tuple.Item1;

bg = tuple.Item2;

continue;

}

throw new ArgumentException("Unexpected type");

}

var extraSpacesNeeded = Console.BufferWidth - (result.Count % Console.BufferWidth);

if (extraSpacesNeeded != 0)

{

var space = new CHAR_INFO(' ', Console.ForegroundColor, Console.BackgroundColor);

result.AddRange(Enumerable.Repeat(space, extraSpacesNeeded));

}

return result.ToArray();

}

static private KeyWithValidation[] Keys(params object[] input)

{

var list = new List<KeyWithValidation>();

foreach (var t in input)

{

if (t is ConsoleKeyInfo)

{

list.Add(new KeyWithValidation((ConsoleKeyInfo)t));

}

else if (t is string)

{

foreach (var c in (string)t)

{

list.Add(new KeyWithValidation(CharToKeyInfo[c]));

}

}

else if (t is char)

{

list.Add(new KeyWithValidation(CharToKeyInfo[(char)t]));

}

else

{

list.Add((KeyWithValidation)t);

}

}

return list.ToArray();

}

private static CHAR_INFO[] ReadBufferLines(int top, int count)

{

var result = new CHAR_INFO[Console.BufferWidth * count];

var handle = NativeMethods.GetStdHandle((uint) StandardHandleId.Output);

var readBufferSize = new COORD {

X = (short)Console.BufferWidth,

Y = (short)count};

var readBufferCoord = new COORD {X = 0, Y = 0};

var readRegion = new SMALL_RECT

{

Top = (short)top,

Left = 0,

Bottom = (short)(top + count),

Right = (short)(Console.BufferWidth - 1)

};

NativeMethods.ReadConsoleOutput(handle, result,

readBufferSize, readBufferCoord, ref readRegion);

return result;

}

private static void ScrollBuffer(int lines)

{

var handle = NativeMethods.GetStdHandle((uint) StandardHandleId.Output);

var scrollRectangle = new SMALL_RECT

{

Top = (short) lines,

Left = 0,

Bottom = (short) (lines + Console.BufferHeight - 1),

Right = (short)Console.BufferWidth

};

var destinationOrigin = new COORD {X = 0, Y = 0};

var fillChar = new CHAR_INFO(' ', Console.ForegroundColor, Console.BackgroundColor);

NativeMethods.ScrollConsoleScreenBuffer(handle, ref scrollRectangle, ref scrollRectangle, destinationOrigin, ref fillChar);

}

private static void WriteBufferLines(CHAR_INFO[] buffer, ref int top)

{

var handle = NativeMethods.GetStdHandle((uint) StandardHandleId.Output);

int bufferWidth = Console.BufferWidth;

int bufferLineCount = buffer.Length / bufferWidth;

if ((top + bufferLineCount) > Console.BufferHeight)

{

var scrollCount = (top + bufferLineCount) - Console.BufferHeight;

ScrollBuffer(scrollCount);

top -= scrollCount;

}

var bufferSize = new COORD

{

X = (short) bufferWidth,

Y = (short) bufferLineCount

};

var bufferCoord = new COORD {X = 0, Y = 0};

var writeRegion = new SMALL_RECT

{

Top = (short) top,

Left = 0,

Bottom = (short) (top + bufferLineCount - 1),

Right = (short) bufferWidth

};

NativeMethods.WriteConsoleOutput(handle, buffer,

bufferSize, bufferCoord, ref writeRegion);

}

private void AssertScreenIs(int lines, params object[] items)

{

var consoleBuffer = ReadBufferLines(0, lines);

var expectedBuffer = CreateCharInfoBuffer(items);

Assert.AreEqual(expectedBuffer.Length, consoleBuffer.Length);

for (var i = 0; i < expectedBuffer.Length; i++)

{

Assert.AreEqual(expectedBuffer[i], consoleBuffer[i]);

}

}

static void SetBufferState(string text, int cursor)

{

var keys = new List<KeyWithValidation>();

keys.AddRange(Keys(text));

keys.Add(new KeyWithValidation(_.Home));

while (cursor-- > 0)

{

keys.Add(new KeyWithValidation(_.RightArrow));

}

keys.Last().Validator = CancelReadLineException.Throw;

Test(keys.ToArray());

}

static void ClearScreen()

{

int bufferWidth = Console.BufferWidth;

const int bufferLineCount = 10;

var consoleBuffer = new CHAR_INFO[bufferWidth * bufferLineCount];

for (int i = 0; i < consoleBuffer.Length; i++)

{

consoleBuffer[i] = new CHAR_INFO(' ', Console.ForegroundColor, Console.BackgroundColor);

}

int top = 0;

WriteBufferLines(consoleBuffer, ref top);

}

static private void SetPrompt(string prompt)

{

if (string.IsNullOrEmpty(prompt))

return;

var handle = NativeMethods.GetStdHandle((uint) StandardHandleId.Output);

var lineCount = 1 + prompt.Count(c => c == '\n');

if (lineCount > 1)

{

var options = new SetPSReadlineOption {ExtraPromptLineCount = lineCount - 1};

PSConsoleReadLine.SetOptions(options);

}

int bufferWidth = Console.BufferWidth;

var consoleBuffer = new CHAR_INFO[lineCount * bufferWidth];

int j = 0;

for (int i = 0; i < prompt.Length; i++, j++)

{

if (prompt[i] == '\n')

{

for (; j % Console.BufferWidth != 0; j++)

{

consoleBuffer[j] = new CHAR_INFO(' ', Console.ForegroundColor, Console.BackgroundColor);

}

Console.CursorTop += 1;

Console.CursorLeft = 0;

j -= 1; // We don't actually write the newline

}

else

{

consoleBuffer[j] = new CHAR_INFO(prompt[i], Console.ForegroundColor, Console.BackgroundColor);

Console.CursorLeft += 1;

}

}

var bufferSize = new COORD

{

X = (short) bufferWidth,

Y = (short) lineCount

};

var bufferCoord = new COORD {X = 0, Y = 0};

var writeRegion = new SMALL_RECT

{

Top = 0,

Left = 0,

Bottom = (short) (lineCount - 1),

Right = (short) bufferWidth

};

NativeMethods.WriteConsoleOutput(handle, consoleBuffer, bufferSize, bufferCoord, ref writeRegion);

}

static private string Test(KeyWithValidation[] keys, string prompt = null)

{

Console.CursorLeft = 0;

Console.CursorTop = 0;

SetPrompt(prompt);

int index = 0;

try

{

using (ShimsContext.Create())

{

PSConsoleUtilities.Fakes.ShimPSConsoleReadLine.ReadKey = () => keys[index].Key;

PSConsoleUtilities.Fakes.ShimPSConsoleReadLine.PostKeyHandler = () =>

{

if (keys[index].Validator != null)

{

keys[index].Validator();

}

index++;

};

System.Management.Automation.Fakes.ShimCommandCompletion.CompleteInputStringInt32HashtablePowerShell =

MockedCompleteInput;

return PSConsoleReadLine.ReadLine();

}

}

catch (CancelReadLineException)

{

return null;

}

}

private string Test(ConsoleKeyInfo[] keys, string prompt = null)

{

Console.CursorLeft = 0;

Console.CursorTop = 0;

SetPrompt(prompt);

int index = 0;

using (ShimsContext.Create())

{

PSConsoleUtilities.Fakes.ShimPSConsoleReadLine.ReadKey = () => keys[index++];

System.Management.Automation.Fakes.ShimCommandCompletion.CompleteInputStringInt32HashtablePowerShell =

MockedCompleteInput;

return PSConsoleReadLine.ReadLine();

}

}

private void TestSetup(KeyMode keyMode, params KeyHandler[] keyHandlers)

{

ClearScreen();

PSConsoleReadLine.ClearHistory();

PSConsoleReadLine.ClearKillRing();

var options = new SetPSReadlineOption

{

AddToHistoryHandler = null,

HistoryNoDuplicates = PSConsoleReadLine.DefaultHistoryNoDuplicates,

MinimumHistoryCommandLength = PSConsoleReadLine.DefaultMinimumHistoryCommandLength,

MaximumHistoryCount = PSConsoleReadLine.DefaultMaximumHistoryCount,

MaximumKillRingCount = PSConsoleReadLine.DefaultMaximumKillRingCount,

ResetTokenColors = true,

};

switch (keyMode)

{

case KeyMode.Cmd:

options.EditMode = EditMode.Windows;

break;

case KeyMode.Emacs:

options.EditMode = EditMode.Emacs;

break;

#if FALSE

case KeyMode.Vi:

options.EditMode = EditMode.Vi;

break;

#endif

}

PSConsoleReadLine.SetOptions(options);

foreach (var keyHandler in keyHandlers)

{

PSConsoleReadLine.SetKeyHandler(keyHandler.Key, false, keyHandler.Handler, "", "");

}

var colorOptions = new SetPSReadlineOption();

foreach (var val in typeof(TokenClassification).GetEnumValues())

{

colorOptions.TokenKind = (TokenClassification)val;

colorOptions.ForegroundColor = ForegroundColors[(int)val];

colorOptions.BackgroundColor = BackgroundColors[(int)val];

PSConsoleReadLine.SetOptions(colorOptions);

}

}

[TestMethod]

public void TestInput()

{

TestSetup(KeyMode.Cmd);

var keys = Keys("exit", _.Enter);

var result = Test(keys); Assert.AreEqual("exit", result);

AssertCursorLeftIs(4);

}

[TestMethod]

public void TestLongLine()

{

TestSetup(KeyMode.Cmd);

var width = Console.BufferWidth;

var sb = new StringBuilder();

var keys = new ConsoleKeyInfo[width + 3];

int i = 0;

keys[i++] = _.DQuote;

sb.Append('"');

while (i < width + 1)

{

keys[i++] = _.Z;

sb.Append('z');

}

keys[i++] = _.DQuote;

sb.Append('"');

keys[i] = _.Enter;

var result = Test(keys); Assert.AreEqual(sb.ToString(), result);

}

[TestMethod]

public void TestEndOfLine()

{

TestSetup(KeyMode.Cmd);

var keys = Keys(

new KeyWithValidation(_.End, () => AssertCursorLeftIs(0)),

new KeyWithValidation(_.Enter)

);

var result = Test(keys); Assert.AreEqual("", result);

TestSetup(KeyMode.Cmd);

var width = Console.BufferWidth;

var buffer = new StringBuilder();

keys = new KeyWithValidation[width * 3];

int i = 0;

while (i < width)

{

keys[i++] = new KeyWithValidation(_.Space);

buffer.Append(' ');

}

keys[i++] = new KeyWithValidation(_.Home, () => AssertCursorLeftIs(0));

keys[i++] = new KeyWithValidation(_.End, () => AssertCursorLeftTopIs(0, 1));

keys[i] = new KeyWithValidation(_.Enter);

result = Test(keys); Assert.AreEqual(buffer.ToString(), result);

for (int j = 0; j < 5; j++)

{

keys[i++] = new KeyWithValidation(_.Space);

buffer.Append(' ');

}

keys[i++] = new KeyWithValidation(_.Home, () => AssertCursorLeftIs(0));

keys[i++] = new KeyWithValidation(_.End, () => AssertCursorLeftTopIs(5, 1));

keys[i] = new KeyWithValidation(_.Enter);

result = Test(keys); Assert.AreEqual(buffer.ToString(), result);

}

[TestMethod]

public void TestCursorMovement()

{

TestSetup(KeyMode.Cmd);

var keysWithValidation = Keys(

new KeyWithValidation(_.LeftArrow, () => AssertCursorLeftIs(0)),

"ace",

new KeyWithValidation(_.LeftArrow, () => AssertCursorLeftIs(2)),

'd',

new KeyWithValidation(_.LeftArrow, () => AssertCursorLeftIs(2)),

new KeyWithValidation(_.LeftArrow, () => AssertCursorLeftIs(1)),

'b', _.Enter

);

var result = Test(keysWithValidation); Assert.AreEqual("abcde", result);

}

[TestMethod]

public void TestMultiLine()

{

TestSetup(KeyMode.Cmd);

var keysWithValidation = Keys(

"d|",

new KeyWithValidation(_.Enter, () => AssertCursorTopIs(1)),

'd', _.Enter

);

var result = Test(keysWithValidation); Assert.AreEqual("d|\nd", result);

// Make sure <ENTER> when input is incomplete actually puts a newline

// wherever the cursor is.

var continationPrefixLength = PSConsoleReadLine.DefaultContinuationPrompt.Length;

keysWithValidation = Keys(

'{',

new KeyWithValidation(_.Enter, () => AssertCursorTopIs(1)),

'd',

new KeyWithValidation(_.Enter, () => AssertCursorTopIs(2)),

new KeyWithValidation(_.Home),

new KeyWithValidation(_.RightArrow, () => AssertCursorLeftTopIs(1, 0)),

new KeyWithValidation(_.Enter, () => AssertCursorLeftTopIs(continationPrefixLength, 1)),

new KeyWithValidation(_.End, () => AssertCursorLeftTopIs(continationPrefixLength, 3)),

'}', _.Enter

);

result = Test(keysWithValidation); Assert.AreEqual("{\n\nd\n}", result);

// Make sure <ENTER> when input successfully parses accepts the input regardless

// of where the cursor is, plus it moves the cursor to the end (so the new prompt

// doesn't overwrite the end of the previous long/multi-line command line.)

keysWithValidation = Keys(

'{',

new KeyWithValidation(_.Enter),

'}',

new KeyWithValidation(_.Home),

new KeyWithValidation(_.Enter, () => AssertCursorLeftTopIs(continationPrefixLength + 1, 1))

);

result = Test(keysWithValidation); Assert.AreEqual("{\n}", result);

}

[TestMethod]

public void TestDelete()

{

TestSetup(KeyMode.Cmd);

// Empty input (does nothing, but don't crash)

var keys = Keys(_.Delete, _.Enter);

var result = Test(keys); Assert.AreEqual("", result);

// At end but input not empty (does nothing, but don't crash)

keys = Keys('a', _.Delete, _.Enter);

result = Test(keys); Assert.AreEqual("a", result);

// Delete last character

keys = Keys("ab", _.LeftArrow, _.Delete, _.Enter);

result = Test(keys); Assert.AreEqual("a", result);

// Delete first character

keys = Keys("ab", _.Home, _.Delete, _.Enter);

result = Test(keys); Assert.AreEqual("b", result);

// Delete middle character

keys = Keys("abc", _.Home, _.RightArrow, _.Delete, _.Enter);

result = Test(keys); Assert.AreEqual("ac", result);

}

[TestMethod]

public void TestBackspace()

{

TestSetup(KeyMode.Cmd);

// Empty input (does nothing but don't crash)

var keys = new [] {_.Backspace, _.Enter};

var result = Test(keys); Assert.AreEqual("", result);

// At end, delete all input

keys = new [] {_.A, _.Backspace, _.Enter};

result = Test(keys); Assert.AreEqual("", result);

// At end, delete all input with extra backspaces

keys = new [] {_.A, _.Backspace, _.Backspace, _.Enter};

result = Test(keys); Assert.AreEqual("", result);

// Delete first character

keys = new [] {_.A, _.B, _.LeftArrow, _.Backspace, _.Enter};

result = Test(keys); Assert.AreEqual("b", result);

// Delete first character with extra backspaces

keys = new [] {_.A, _.B, _.LeftArrow, _.Backspace, _.Backspace, _.Enter};

result = Test(keys); Assert.AreEqual("b", result);

// Delete middle character

keys = new [] {_.A, _.B, _.C, _.LeftArrow, _.Backspace, _.Enter};

result = Test(keys); Assert.AreEqual("ac", result);

}

[TestMethod]

public void TestAddLine()

{

TestSetup(KeyMode.Cmd);

var keys = new[] {_._1, _.ShiftEnter, _._2, _.Enter};

var result = Test(keys); Assert.AreEqual("1\n2", result);

}

[TestMethod]

public void TestIgnore()

{

TestSetup(KeyMode.Emacs);

var keys = new[] {_.A, _.VolumeDown, _.VolumeMute, _.VolumeUp, _.B, _.Enter};

var result = Test(keys); Assert.AreEqual("ab", result);

}

[TestMethod]

public void TestTabComplete()

{

TestSetup(KeyMode.Cmd);

var keys = new [] {_.Dollar, _.T, _.R, _.Tab, _.Enter};

var result = Test(keys); Assert.AreEqual("$true", result);

AssertCursorLeftIs(5);

// Validate no change on no match

keys = new [] {_.Dollar, _.Z, _.Z, _.Tab, _.Enter};

result = Test(keys); Assert.AreEqual("$zz", result);

AssertCursorLeftIs(3);

var keysWithValidation = new []

{

new KeyWithValidation(_.Dollar),

new KeyWithValidation(_.T),

new KeyWithValidation(_.Tab, () => AssertLineIs("$this")),

new KeyWithValidation(_.Tab, () => AssertLineIs("$true")),

new KeyWithValidation(_.Tab, () => AssertLineIs("$this")),

new KeyWithValidation(_.ShiftTab, () => AssertLineIs("$true")),