using Microsoft.PowerShell;

using System;

using System.Linq;

using System.Runtime.InteropServices;

using Xunit;

namespace Test

{

public partial class ReadLine

{

[SkippableFact]

public void Input()

{

TestSetup(KeyMode.Cmd);

Test("exit", Keys(

"exit",

_.Enter,

CheckThat(() => AssertCursorLeftIs(0))));

}

[SkippableFact]

public void RevertLine()

{

// Add one test for chords

TestSetup(KeyMode.Cmd, new KeyHandler("Ctrl+x,Escape", PSConsoleReadLine.RevertLine));

Test("ls", Keys("di", _.Escape, "ls"));

Test("ls", Keys("di", _.Ctrl_x, _.Escape, "ls"));

TestSetup(KeyMode.Emacs);

Test("ls", Keys("di", _.Escape, _.r, "ls"));

Test("ls", Keys("di", _.Alt_r, "ls"));

}

[SkippableFact]

public void CancelLine()

{

TestSetup(KeyMode.Cmd, new KeyHandler("Ctrl+C", PSConsoleReadLine.CancelLine));

Test("", Keys("oops", _.Ctrl_C,

CheckThat(() => AssertScreenIs(1,

TokenClassification.Command, "oops",

Tuple.Create(ConsoleColor.Red, _console.BackgroundColor), "^C")),

InputAcceptedNow));

Test("", Keys("exit", _.Ctrl_C,

CheckThat(() => AssertScreenIs(1,

TokenClassification.Keyword, "exit",

Tuple.Create(ConsoleColor.Red, _console.BackgroundColor), "^C")),

InputAcceptedNow));

// Test near/at/over buffer width input

var width = _console.BufferWidth;

var line1 = new string('a', width - 2);

Test("", Keys(line1, _.Ctrl_C,

CheckThat(() => AssertScreenIs(1,

TokenClassification.Command, line1,

Tuple.Create(ConsoleColor.Red, _console.BackgroundColor), "^C")),

InputAcceptedNow));

var line2 = new string('a', width - 1);

Test("", Keys(line2, _.Ctrl_C,

CheckThat(() => AssertScreenIs(2,

TokenClassification.Command, line2,

Tuple.Create(ConsoleColor.Red, _console.BackgroundColor), "^C")),

InputAcceptedNow));

var line3 = new string('a', width);

Test("", Keys(line3, _.Ctrl_C,

CheckThat(() => AssertScreenIs(2,

TokenClassification.Command, line3,

Tuple.Create(ConsoleColor.Red, _console.BackgroundColor), "^C")),

InputAcceptedNow));

}

[SkippableFact]

public void ForwardDeleteInput()

{

ConsoleKeyInfo deleteToEnd;

if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))

{

TestSetup(KeyMode.Cmd);

deleteToEnd = _.Ctrl_End;

}

else

{

TestSetup(KeyMode.Emacs);

deleteToEnd = _.Ctrl_k;

}

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

Test("", Keys("", deleteToEnd));

// at end of input - doesn't change anything

Test("abc", Keys("abc", deleteToEnd));

// More normal usage - actually delete stuff

Test("a", Keys("abc", _.LeftArrow, _.LeftArrow, deleteToEnd));

}

[SkippableFact]

public void ForwardDeleteLine()

{

TestSetup(KeyMode.Emacs);

PSConsoleReadLine.SetKeyHandler(new[] { "Shift+Tab" }, PSConsoleReadLine.ForwardDeleteLine, "", "");

Test("\"H\nWorld\"", Keys(

_.DQuote, "Hello", _.Enter,

"World", _.DQuote,

_.Home, _.Home, _.RightArrow, _.RightArrow,

_.Shift_Tab // delete to the end of the current logical line

));

}

[SkippableFact]

public void BackwardDeleteInput()

{

TestSetup(KeyMode.Cmd);

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

Test("", Keys(_.Ctrl_Home));

// at beginning of input - doesn't change anything

Test("abc", Keys("abc", _.Home, _.Ctrl_Home));

// More typical usage

Test("c", Keys("abc", _.LeftArrow, _.Ctrl_Home));

Test("", Keys("abc", _.Ctrl_Home));

}

[SkippableFact]

public void BackwardDeleteChar()

{

TestSetup(KeyMode.Cmd);

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

Test("", Keys("", _.Backspace));

// At end, delete all input

Test("", Keys("a", _.Backspace));

// At end, delete all input with extra backspaces

Test("", Keys("a", _.Backspace, _.Backspace));

// Delete first character

Test("b", Keys("ab", _.LeftArrow, _.Backspace));

// Delete first character with extra backspaces

Test("b", Keys("ab", _.LeftArrow, _.Backspace, _.Backspace));

// Delete middle character

Test("ac", Keys("abc", _.LeftArrow, _.Backspace));

}

[SkippableFact]

public void DeleteChar()

{

TestSetup(KeyMode.Cmd);

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

Test("", Keys(_.Delete));

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

Test("a", Keys('a', _.Delete));

// Delete last character

Test("a", Keys("ab", _.LeftArrow, _.Delete));

// Delete first character

Test("b", Keys("ab", _.Home, _.Delete));

// Delete middle character

Test("ac", Keys("abc", _.Home, _.RightArrow, _.Delete));

}

[SkippableFact]

public void DeleteCharAfterDigitArgument()

{

TestSetup(KeyMode.Cmd);

Test("abc", Keys(

"ab", _.LeftArrow, _.Alt_2, _.Delete,

CheckThat(() => AssertLineIs("a")),

CheckThat(() => AssertCursorLeftIs(1)),

_.Delete, // 'Delete' again does nothing, but doesn't crash

CheckThat(() => AssertLineIs("a")),

CheckThat(() => AssertCursorLeftIs(1)),

"bc"));

}

[SkippableFact]

public void DeleteCharOrExit()

{

TestSetup(KeyMode.Emacs);

Test("exit", Keys(_.Ctrl_d, InputAcceptedNow));

Test("foo", Keys("foo", _.Ctrl_d));

Test("oo", Keys("foo", _.Home, _.Ctrl_d));

Test("exit", Keys("foo", _.Home, Enumerable.Repeat(_.Ctrl_d, 4), InputAcceptedNow));

}

[SkippableFact]

public void UpcaseWord()

{

TestSetup(KeyMode.Emacs);

Test("FOO", Keys("foo", _.Alt_b, _.Alt_u));

Test("FOO bar", Keys("foo bar", _.Home, _.Alt_u));

Test("foo BAR", Keys("foo bar", _.Alt_b, _.Alt_u));

Test("FOO BAR", Keys("foo bar", _.Home, Enumerable.Repeat(_.Alt_u, 2)));

}

[SkippableFact]

public void DowncaseWord()

{

TestSetup(KeyMode.Emacs);

Test("foo", Keys("fOO", _.Alt_b, _.Alt_l));

Test("FOO bar", Keys("FOO BAR", _.Alt_b, _.Alt_l));

Test("foo BAR", Keys("FOO BAR", _.Home, _.Alt_l));

Test("foo bar", Keys("FOO BAR", _.Home, Enumerable.Repeat(_.Alt_l, 2)));

}

[SkippableFact]

public void CapitalizeWord()

{

TestSetup(KeyMode.Emacs);

Test("Foo", Keys("fOO", _.Alt_b, _.Alt_c));

Test("fOO Bar", Keys("fOO bAR", _.Alt_b, _.Alt_c));

Test("Foo BAR", Keys("fOO BAR", _.Home, _.Alt_c));

Test("Foo Bar", Keys("fOO BAR", _.Home, Enumerable.Repeat(_.Alt_c, 2)));

Test("Foo ^&*() Bar", Keys("Foo ^&*() bar", _.Home, Enumerable.Repeat(_.Alt_c, 2)));

}

[SkippableFact]

public void SelectAndDelete()

{

TestSetup(KeyMode.Cmd);

Test("abcde", Keys(

"abcde",

CheckThat(() => AssertCursorLeftIs(5)),

_.Shift_LeftArrow, _.Shift_LeftArrow, _.Shift_LeftArrow,

_.Backspace,

CheckThat(() => AssertLineIs("ab")),

CheckThat(() => AssertCursorLeftIs(2)),

_.Ctrl_z,

CheckThat(() => AssertLineIs("abcde")),

CheckThat(() => AssertCursorLeftIs(5))));

Test("abcde", Keys(

"abcde", _.Home,

CheckThat(() => AssertCursorLeftIs(0)),

_.RightArrow, _.RightArrow,

CheckThat(() => AssertCursorLeftIs(2)),

_.Shift_RightArrow, _.Shift_RightArrow,

_.Delete,

CheckThat(() => AssertLineIs("abe")),

CheckThat(() => AssertCursorLeftIs(2)),

_.Ctrl_z,

CheckThat(() => AssertLineIs("abcde")),

CheckThat(() => AssertCursorLeftIs(4))));

}

[SkippableFact]

public void SwapCharacters()

{

TestSetup(KeyMode.Emacs);

TestMustDing("", Keys(_.Ctrl_t));

TestMustDing("a", Keys("a", _.Ctrl_t));

TestMustDing("abc", Keys("abc", _.Home, _.Ctrl_t));

Test("abc", Keys(

"abc", CheckThat(() => AssertLineIs("abc")),

_.Ctrl_t, CheckThat(() => AssertLineIs("acb")),

_.Ctrl_Underbar, CheckThat(() => AssertCursorLeftIs(3))

));

Test("abcd", Keys(

"abcd", CheckThat(() => AssertLineIs("abcd")),

_.Ctrl_a, _.Ctrl_t, CheckThat(() => AssertLineIs("abcd")),

_.Ctrl_f, Enumerable.Repeat(_.Ctrl_t, 3), CheckThat(() => AssertLineIs("bcda")),

_.Ctrl_t, CheckThat(() => AssertLineIs("bcad")),

Enumerable.Repeat(_.Ctrl_Underbar, 4)

));

}

[SkippableFact]

public void AcceptAndGetNext()

{

TestSetup(KeyMode.Emacs);

// No history

Test("", Keys(_.Ctrl_o, InputAcceptedNow));

// One item in history

SetHistory("echo 1");

Test("", Keys(_.Ctrl_o, InputAcceptedNow));

// Two items in history, make sure after Ctrl+O, second history item

// is recalled.

SetHistory("echo 1", "echo 2");

Test("echo 1", Keys(_.UpArrow, _.UpArrow, _.Ctrl_o, InputAcceptedNow));

Test("echo 2", Keys(_.Enter));

// Test that the current saved line is saved after AcceptAndGetNext

SetHistory("echo 1", "echo 2");

Test("echo 1", Keys("e", _.UpArrow, _.UpArrow, _.Ctrl_o, InputAcceptedNow));

Test("e", Keys(_.DownArrow, _.DownArrow, _.Enter));

// Test that we can edit after recalling the current line

SetHistory("echo 1", "echo 2");

Test("echo 1", Keys("e", _.UpArrow, _.UpArrow, _.Ctrl_o, InputAcceptedNow));

Test("eee", Keys(_.DownArrow, _.DownArrow, "ee", _.Enter));

}

[SkippableFact]

public void AcceptAndGetNextWithHistorySearch()

{

TestSetup(KeyMode.Emacs,

new KeyHandler("UpArrow", PSConsoleReadLine.HistorySearchBackward),

new KeyHandler("DownArrow", PSConsoleReadLine.HistorySearchForward));

// Test that after AcceptAndGetNext, the previous search is not applied

SetHistory("echo 1", "echo 2", "zzz");

Test("echo 1", Keys("e", _.UpArrow, _.UpArrow, _.Ctrl_o, InputAcceptedNow));

Test("zzz", Keys(_.DownArrow, _.Enter));

}

[SkippableFact]

public void AddLine()

{

TestSetup(KeyMode.Cmd);

Test("1\n2", Keys('1', _.Shift_Enter, '2'));

}

[SkippableFact]

public void InsertLineAbove()

{

TestSetup(KeyMode.Cmd);

// Test case - start with single line, cursor at end

Test("56\n1234", Keys("1234", _.Ctrl_Enter, CheckThat(() => AssertCursorLeftTopIs(0, 0)), "56"));

// Test case - start with single line, cursor in home position

Test("56\n1234", Keys("1234", _.Home, _.Ctrl_Enter, CheckThat(() => AssertCursorLeftTopIs(0, 0)), "56"));

// Test case - start with single line, cursor in middle

Test("56\n1234", Keys("1234",

_.LeftArrow, _.LeftArrow, _.Ctrl_Enter, CheckThat(() => AssertCursorLeftTopIs(0, 0)),

"56"));

// Test case - start with multi-line, cursor at end of second line (end of input)

Test("1234\n9ABC\n5678", Keys("1234", _.Shift_Enter, "5678",

_.Ctrl_Enter, CheckThat(() => AssertCursorLeftTopIs(ContinuationPromptLength, 1)),

"9ABC"));

// Test case - start with multi-line, cursor at beginning of second line

Test("1234\n9ABC\n5678", Keys("1234", _.Shift_Enter, "5678",

_.LeftArrow, _.Home, CheckThat(() => AssertCursorLeftTopIs(ContinuationPromptLength, 1)),

_.Ctrl_Enter, CheckThat(() => AssertCursorLeftTopIs(ContinuationPromptLength, 1)),

"9ABC"));

// Test case - start with multi-line, cursor at end of first line

Test("9ABC\n1234\n5678", Keys("1234", _.Shift_Enter, "5678",

_.UpArrow, _.LeftArrow, _.End, CheckThat(() => AssertCursorLeftTopIs(4, 0)),

_.Ctrl_Enter, CheckThat(() => AssertCursorLeftTopIs(0, 0)),

"9ABC"));

// Test case - start with multi-line, cursor at beginning of first line - temporarily having to press Home twice to

// work around bug in home handler.

Test("9ABC\n1234\n5678", Keys("1234", _.Shift_Enter, "5678",

_.UpArrow, _.LeftArrow, _.Home, _.Home, CheckThat(() => AssertCursorLeftTopIs(0, 0)),

_.Ctrl_Enter, CheckThat(() => AssertCursorLeftTopIs(0, 0)),

"9ABC"));

// Test case - insert multiple blank lines

Test("1234\n9ABC\n\n5678", Keys("1234", _.Shift_Enter, "5678",

_.Ctrl_Enter, CheckThat(() => AssertCursorLeftTopIs(ContinuationPromptLength, 1)),

_.Ctrl_Enter, CheckThat(() => AssertCursorLeftTopIs(ContinuationPromptLength, 1)),

"9ABC"));

// Test case - create leading blank line, cursor to stay on same line

Test("\n\n1234", Keys("1234",

_.Ctrl_Enter, CheckThat(() => AssertCursorLeftTopIs(0,0)),

_.DownArrow, CheckThat(() => AssertCursorLeftTopIs(ContinuationPromptLength, 1)),

_.Ctrl_Enter, CheckThat(() => AssertCursorLeftTopIs(ContinuationPromptLength, 1))));

}

[SkippableFact]

public void InsertLineBelow()

{

TestSetup(KeyMode.Cmd);

// Test case - start with single line, cursor at end

Test("1234\n56", Keys("1234",

_.Ctrl_Shift_Enter, CheckThat(() => AssertCursorLeftTopIs(ContinuationPromptLength, 1)),

"56"));

// Test case - start with single line, cursor in home position

Test("1234\n56", Keys("1234",

_.Home, _.Ctrl_Shift_Enter, CheckThat(() => AssertCursorLeftTopIs(ContinuationPromptLength, 1)),

"56"));

// Test case - start with single line, cursor in middle

Test("1234\n56", Keys("1234",

_.LeftArrow, _.LeftArrow, _.Ctrl_Shift_Enter, CheckThat(() => AssertCursorLeftTopIs(ContinuationPromptLength, 1)),

"56"));

// Test case - start with multi-line, cursor at end of second line (end of input)

Test("1234\n5678\n9ABC", Keys("1234", _.Shift_Enter, "5678",

_.Ctrl_Shift_Enter, CheckThat(() => AssertCursorLeftTopIs(ContinuationPromptLength, 2)),

"9ABC"));

// Test case - start with multi-line, cursor at beginning of second line

Test("1234\n5678\n9ABC", Keys("1234", _.Shift_Enter, "5678",

_.LeftArrow, _.Home, CheckThat(() => AssertCursorLeftTopIs(ContinuationPromptLength, 1)),

_.Ctrl_Shift_Enter, CheckThat(() => AssertCursorLeftTopIs(ContinuationPromptLength, 2)),

"9ABC"));

// Test case - start with multi-line, cursor at end of first line

Test("1234\n9ABC\n5678", Keys("1234", _.Shift_Enter, "5678",

_.UpArrow, _.LeftArrow, _.End, CheckThat(() => AssertCursorLeftTopIs(4, 0)),

_.Ctrl_Shift_Enter, CheckThat(() => AssertCursorLeftTopIs(ContinuationPromptLength, 1)),

"9ABC"));

// Test case - start with multi-line, cursor at beginning of first line - temporarily having to press Home twice to

// work around bug in home handler.

Test("1234\n9ABC\n5678", Keys("1234", _.Shift_Enter, "5678",

_.UpArrow, _.LeftArrow, _.Home, _.Home, CheckThat(() => AssertCursorLeftTopIs(0, 0)),

_.Ctrl_Shift_Enter, CheckThat(() => AssertCursorLeftTopIs(ContinuationPromptLength, 1)),

"9ABC"));

// Test case - insert multiple blank lines

Test("1234\n5678\n\n9ABC", Keys("1234", _.Shift_Enter, "5678",

_.Ctrl_Shift_Enter, CheckThat(() => AssertCursorLeftTopIs(ContinuationPromptLength, 2)),

_.Ctrl_Shift_Enter, CheckThat(() => AssertCursorLeftTopIs(ContinuationPromptLength, 3)),

"9ABC"));

}

[SkippableFact]

public void MultilineHomeBugFixed()

{

TestSetup(KeyMode.Cmd);

// Going from second line to first line, press left arrow and then home.

// That puts cursor in column 1 instead of 0. Bug? This could have something

// to do with BeginningOfLine testing against i > 1 in multiline edit instead

// of i > 0.

Test("1234\n9ABC", Keys("1234", _.Shift_Enter, "9ABC", _.UpArrow, _.LeftArrow, _.Home, CheckThat(() => AssertCursorLeftTopIs(0, 0))));

}

[SkippableFact]

public void Ignore()

{

TestSetup(KeyMode.Emacs);

Test("ab", Keys("a", _.VolumeDown, _.VolumeMute, _.VolumeUp, "b"));

}

}

}