using System;

using System.Linq;

using Microsoft.PowerShell;

using Xunit;

namespace Test

{

public partial class ReadLine

{

private ConsoleKeyInfo[] StringToCKI(string str)

{

return str.Select(c => new ConsoleKeyInfo(c, 0, false, false, false)).ToArray();

}

[Fact]

public void MapControlChars()

{

var map = new WindowsAnsiCharMap();

// Enter (Ctrl+J)

map.ProcessKey(new ConsoleKeyInfo('\x0D', 0, false, false, false));

Assert.True(map.KeyAvailable);

var processedKey = map.ReadKey();

Assert.Equal(ConsoleKey.Enter, processedKey.Key);

Assert.Equal((ConsoleModifiers)0, processedKey.Modifiers);

Assert.False(map.KeyAvailable);

// Ctrl+C

map.ProcessKey(new ConsoleKeyInfo('\x03', 0, false, false, false));

processedKey = map.ReadKey();

Assert.Equal(ConsoleKey.C, processedKey.Key);

Assert.Equal(ConsoleModifiers.Control, processedKey.Modifiers);

}

private void CheckEscapeInput(ICharMap map, ConsoleKeyInfo intended, ConsoleKeyInfo[] keys, bool inputOnly = false)

{

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

{

map.ProcessKey(keys[i]);

if (i < keys.Length - 1)

{

Assert.False(map.KeyAvailable);

}

}

if (inputOnly)

{

// Hack to make the map process escapes now.

var escapeTimeout = map.EscapeTimeout;

map.EscapeTimeout = 0;

bool unused = map.KeyAvailable;

map.EscapeTimeout = escapeTimeout;

return;

}

Assert.True(map.KeyAvailable);

var processedKey = map.ReadKey();

Assert.False(map.KeyAvailable);

Assert.Equal(intended, processedKey);

}

[Fact]

public void ValidEscapeSequences()

{

// Use a high timeout value so there's no way it will try to convert

// part of a sequence to Alt+something.

var map = new WindowsAnsiCharMap(1000);

// ^[[A = UpArrow

CheckEscapeInput(map, _.UpArrow, StringToCKI("\x1b[A"));

// ^[OA = UpArrow (alternate form)

CheckEscapeInput(map, _.UpArrow, StringToCKI("\x1bOA"));

// ^[[1;2B = Shift+DownArrow

CheckEscapeInput(map,

new ConsoleKeyInfo('\0', ConsoleKey.DownArrow, shift: true, alt: false, control: false),

StringToCKI("\x1b[1;2B")

);

// ^[[1;8C = Ctrl+Alt+Shift+RightArrow

CheckEscapeInput(map,

new ConsoleKeyInfo('\0', ConsoleKey.RightArrow, shift: true, alt: true, control: true),

StringToCKI("\x1b[1;8C")

);

// ^[[1;6D = Ctrl+Shift+LeftArrow

CheckEscapeInput(map,

new ConsoleKeyInfo('\0', ConsoleKey.LeftArrow, shift: true, alt: false, control: true),

StringToCKI("\x1b[1;6D")

);

// ^[[3~ = Delete

CheckEscapeInput(map,

new ConsoleKeyInfo('\0', ConsoleKey.Delete, shift: false, alt: false, control: false),

StringToCKI("\x1b[3~")

);

// ^[[15;5~ = Control+F5

CheckEscapeInput(map,

new ConsoleKeyInfo('\0', ConsoleKey.F5, shift: false, alt: false, control: true),

StringToCKI("\x1b[15;5~")

);

}

[Fact]

public void AltSequences()

{

var map = new WindowsAnsiCharMap(1000);

// ^[[ = Alt+[

CheckEscapeInput(map, default(ConsoleKeyInfo), StringToCKI("\x1b["), true);

var processedKey = map.ReadKey();

Assert.Equal('[', processedKey.KeyChar);

Assert.Equal(ConsoleModifiers.Alt, processedKey.Modifiers);

Assert.False(map.KeyAvailable);

// ^[j = Alt+j

CheckEscapeInput(map, default(ConsoleKeyInfo), StringToCKI("\x1bj"), true);

processedKey = map.ReadKey();

Assert.Equal('j', processedKey.KeyChar);

Assert.Equal(ConsoleModifiers.Alt, processedKey.Modifiers);

Assert.False(map.KeyAvailable);

// ^[X = Alt+X

// Currently shift is not set for capitals, so just check the alt

// parts to allow that behavior to change without breaking this test.

CheckEscapeInput(map, default(ConsoleKeyInfo), StringToCKI("\x1bX"), true);

processedKey = map.ReadKey();

Assert.Equal('X', processedKey.KeyChar);

Assert.Equal(ConsoleModifiers.Alt, processedKey.Modifiers & ConsoleModifiers.Alt);

Assert.False(map.KeyAvailable);

// ^[^A = Alt+Ctrl+A

CheckEscapeInput(map, default(ConsoleKeyInfo), StringToCKI("\x1b\x01"), true);

processedKey = map.ReadKey();

Assert.Equal('\x01', processedKey.KeyChar);

Assert.Equal(ConsoleModifiers.Alt | ConsoleModifiers.Control, processedKey.Modifiers);

Assert.False(map.KeyAvailable);

// This is a "tricky" one since ^[O can start a sequence and the second

// escape needs to cancel sequence processing, make an Alt+O available,

// and after that has been read make Esc available.

// ^[O^[ = Alt+O Esc

var consoleKeys = StringToCKI("\x1bO\x1b");

foreach (var ck in consoleKeys)

{

map.ProcessKey(ck);

}

Assert.True(map.KeyAvailable);

processedKey = map.ReadKey();

// Alt+O

Assert.Equal('O', processedKey.KeyChar);

Assert.Equal(ConsoleModifiers.Alt, processedKey.Modifiers);

// Make the map stop looking for an escape sequence.

map.EscapeTimeout = 0;

// Esc

Assert.True(map.KeyAvailable);

Assert.Equal('\x1b', map.ReadKey().KeyChar);

Assert.False(map.KeyAvailable);

map.EscapeTimeout = 1000;

// ^[^[ = Esc Esc, not Alt+Esc.

consoleKeys = StringToCKI("\x1b\x1b");

foreach (var ck in consoleKeys)

{

map.ProcessKey(ck);

}

Assert.True(map.KeyAvailable);

map.ReadKey();

map.EscapeTimeout = 0;

Assert.True(map.KeyAvailable);

map.ReadKey();

}

private void CheckPartialEscapeInput(ICharMap map, int expectedCount, ConsoleKeyInfo[] keys)

{

foreach (var key in keys)

{

map.ProcessKey(key);

Assert.False(map.KeyAvailable);

}

int keyCount = 0;

// Hack to make the map think the timeout is up.

var escapeTimeout = map.EscapeTimeout;

map.EscapeTimeout = 0;

while (map.KeyAvailable)

{

map.ReadKey();

keyCount++;

}

Assert.Equal(expectedCount, keyCount);

map.EscapeTimeout = escapeTimeout;

}

[Fact]

public void PartialEscapeSequences()

{

var map = new WindowsAnsiCharMap(1000);

// Just escape

CheckPartialEscapeInput(map, 1, StringToCKI("\x1b"));

// ^[[1;2

CheckPartialEscapeInput(map, 5, StringToCKI("\x1b[1;2"));

// ^[[11

CheckPartialEscapeInput(map, 4, StringToCKI("\x1b[11"));

// ^[O -> Alt+O

CheckPartialEscapeInput(map, 1, StringToCKI("\x1bO"));

}

}

}