fix: use full path for configs

[jpoon]

What this PR does / why we need it:

• Enable auto-complete when trying to configure statusbar colors and custom cursors for mode.
• Remove need for having to create a map of the custom cursors every tick.

Which issue(s) this PR fixes

Special notes for your reviewer:

[xconverge]

This might break some people's configs who are using more undocumented modes

[jpoon]

True. Should add them all then.

Edit: Actually, we cast everything back to IModeSpecificStrings so it's not possible to use all the other modes for these configurations.

[TravisBuddy]

Travis tests have failed

Hey @jpoon,
Please read the following log in order to understand the failure reason.
It'll be awesome if you fix what's wrong and commit the changes.

Node.js: 8

npm test --silent

### VS Code Extension Test Run ###
Current working directory: /home/travis/build/VSCodeVim/Vim
Downloading VS Code into "/home/travis/build/VSCodeVim/Vim/.vscode-test/stable" from: https://vscode-update.azurewebsites.net/1.25.1/linux-x64/stable
Running extension tests: /home/travis/build/VSCodeVim/Vim/.vscode-test/stable/VSCode-linux-x64/code /home/travis/build/VSCodeVim/Vim/out/test --extensionDevelopmentPath=/home/travis/build/VSCodeVim/Vim --extensionTestsPath=/home/travis/build/VSCodeVim/Vim/out/test
Xlib:  extension "RANDR" missing on display ":99.0".

Xlib:  extension "RANDR" missing on display ":99.0".

[main 9:47:04 AM] update#setState idle

bash: cannot set terminal process group (-1): Inappropriate ioctl for device

bash: no job control in this shell

nvm is not compatible with the "npm_config_prefix" environment variable: currently set to "/home/travis/.nvm/versions/node/v8.11.3"
Run `unset npm_config_prefix` to unset it.





  base action

    ✓ compare key presses

    ✓ couldActionApply 1D keys positive
    ✓ couldActionApply 1D keys negative
    ✓ couldActionApply 2D keys positive
    ✓ couldActionApply 2D keys negative
    ✓ doesActionApply 1D keys positive
    ✓ doesActionApply 1D keys negative
    ✓ doesActionApply 2D keys positive
    ✓ doesActionApply 2D keys negative



  command-line history

    ✓ add command (92ms)

    ✓ add empty command (54ms)

    ✓ add command over configuration.history (356ms)

    ✓ add command that exists in history (84ms)

    ✓ load and save history

    ✓ change configuration.history



  command-line lexer

    ✓ can lex empty string

    ✓ can lex comma

    ✓ can lex percent

    ✓ can lex dollar

    ✓ can lex dot

    ✓ can lex one number

    ✓ can lex longer number

    ✓ can lex plus

    ✓ can lex minus

    ✓ can lex forward search

    ✓ can lex forward search escaping

    ✓ can lex reverse search

    ✓ can lex reverse search escaping

    ✓ can lex command name

    ✓ can lex command args

    ✓ can lex command args with leading whitespace

    ✓ can lex long command name and args

    ✓ can lex left and right line refs



  command-line parser

    ✓ can parse empty string

    ✓ can parse left - dot

    ✓ can parse left - dollar

    ✓ can parse left - percent

    ✓ can parse separator - comma

    ✓ can parse right - dollar



  command line scanner

    ✓ ctor

    ✓ can detect EOF with empty input

    ✓ next() returns EOF at EOF

    ✓ can scan

    ✓ can emit

    ✓ can ignore

    ✓ can skip whitespace

    ✓ can skip whitespace with one char before EOF

    ✓ can skip whitespace at EOF

    ✓ nextWord() return EOF at EOF

    ✓ nextWord() return word before trailing spaces
    ✓ nextWord() can skip whitespaces and return word 

    ✓ nextWord() return word before EOF

    ✓ can expect one of a set

    ✓ can expect only one of a set



  Basic sort

    ✓ Sort whole file, asc (304ms)

    ✓ Sort whole file, dsc (184ms)

    ✓ Sort range, asc (284ms)

    ✓ Sort range, dsc (278ms)



  :close args parser

    ✓ has all aliases

    ✓ can parse empty args

    ✓ ignores trailing white space

    ✓ can parse !

    ✓ throws if space before !

    ✓ ignores space after !

    ✓ throws if bad input



  :quit args parser

    ✓ has all aliases

    ✓ can parse empty args

    ✓ ignores trailing white space

    ✓ can parse !

    ✓ throws if space before !

    ✓ ignores space after !

    ✓ throws if bad input



  :substitute args parser

    ✓ can parse pattern, replace, and flags

    ✓ can parse count

    ✓ can parse custom delimiter

    ✓ can escape delimiter

    ✓ can parse flag KeepPreviousFlags



  :write args parser

    ✓ has all aliases

    ✓ can parse empty args

    ✓ can parse ++opt

    ✓ throws if bad ++opt name

    ✓ can parse bang

    ✓ can parse ' !cmd'

    ✓ can parse ' !cmd' when cmd is empty



  Basic substitute

    ✓ Replace single word once (150ms)

    ✓ Replace with `g` flag (127ms)

    ✓ Replace multiple lines (275ms)

    ✓ Replace across specific lines (230ms)

    ✓ Replace current line with no active selection (265ms)

    ✓ Replace text in selection (309ms)

    ✓ Substitute support marks (319ms)

    Effects of substituteGlobalFlag=true

      ✓ Replace all matches in the line (173ms)

      ✓ Replace with `g` flag inverts global flag (184ms)

      ✓ Replace multiple lines (182ms)

      ✓ Replace across specific lines (180ms)

      ✓ Replace current line with no active selection (402ms)

      ✓ Replace text in selection (402ms)

      ✓ Substitute support marks (285ms)

      ✓ Substitute with escaped delimiter (143ms)

    Substitute with empty search string should use previous search

      ✓ Substitute with previous search using * (640ms)

      ✓ Substitute with previous search using # (517ms)

      ✓ Substitute with previous search using / (401ms)

      ✓ Substitute with empty search string should use last searched pattern (479ms)



  cmd_line tab

    ✓ tabe with no arguments when not in workspace opens an untitled file (72ms)

    ✓ tabedit with no arguments when not in workspace opens an untitled file (51ms)

    ✓ tabe with absolute path when not in workspace opens file (115ms)

    ✓ tabe with current file path does nothing (103ms)



  Vertical split

    ✓ Run :vs (161ms)

    ✓ Run :vsp (119ms)



  Basic write-quit

    ✓ Run write and quit (284ms)

  Configuration

    ✓ remappings are normalized

    ✓ Can handle long key chords (74ms)

    ✓ whichwrap is parsed into wrapKeys



  Notation

    ✓ Normalize



  Remapper

    ✓ getLongestedRemappedKeySequence

    ✓ getMatchingRemap

    ✓ jj -> <Esc> through modehandler (82ms)

TextEditor is closed/disposed

TextEditor is closed/disposed

TextEditor is closed/disposed

TextEditor is closed/disposed

TextEditor is closed/disposed

    ✓ 0 -> :wq through modehandler (75ms)

    ✓ leader, w -> closeActiveEditor in normal mode through modehandler

    ✓ leader, c -> closeActiveEditor in visual mode through modehandler (49ms)



  Error

    ✓ error code has message



  package.json

    ✓ all keys have handlers

    ✓ all defined configurations in package.json have handlers



  Record and execute a macro

    ✓ Can record and execute (418ms)

    ✓ Can repeat last invoked macro (528ms)

    ✓ Can play back with count (510ms)

    ✓ Can play back with count, abort when a motion fails (627ms)

    ✓ Repeat change on contiguous lines (303ms)

    ✓ Append command to a macro (290ms)

    ✓ Can record Ctrl Keys and repeat (178ms)

    ✓ Can execute macros with dot commands properly (177ms)



  Mode Handler

    ✓ ctor

    ✓ can set current mode



  Mode Handler Map

    ✓ getOrCreate


  Mode Insert

    ✓ can be activated (117ms)

    ✓ can handle key events (62ms)

    ✓ <Esc> should change cursor position (118ms)

    ✓ <C-c> can exit insert (88ms)

    ✓ <Esc> can exit insert (90ms)

    ✓ Stay in insert when entering characters (125ms)

    ✓ Can handle 'O' (108ms)

    ✓ Can handle 'i' (227ms)

    ✓ Can handle 'I' (153ms)

    ✓ Can handle 'a' (313ms)

    ✓ Can handle 'A' (127ms)

    ✓ Can handle '<C-w>' (194ms)

    ✓ Can handle <C-w> on leading whitespace (93ms)

    ✓ Can handle <C-w> at beginning of line (140ms)

    ✓ Can handle <C-u> (219ms)

    ✓ Can handle <C-u> on leading characters (133ms)

    ✓ Can handle <C-u> on leading whitespace (78ms)

[main 9:47:34 AM] update#setState checking for updates

    ✓ Correctly places the cursor after deleting the previous line break (129ms)

    ✓ will not remove leading spaces input by user (62ms)

[main 9:47:34 AM] update#setState idle

    ✓ will remove closing bracket (58ms)

    ✓ Backspace works on whitespace only lines (126ms)

    ✓ Backspace works on end of whitespace only lines (96ms)

    ✓ Backspace works at beginning of file (111ms)

    ✓ Can perform <ctrl+o> to exit and perform one command in normal (120ms)

    ✓ Can perform <ctrl+o> to exit and perform one command in normal at the beginning of a row (185ms)

    ✓ Can perform insert command prefixed with count (127ms)

    ✓ Can perform append command prefixed with count (134ms)

    ✓ Can perform insert at start of line command prefixed with count (109ms)

    ✓ Can perform append to end of line command prefixed with count (103ms)

    ✓ Can perform change char (s) command prefixed with count (174ms)

    ✓ Can perform command prefixed with count with <C-[> (162ms)

    ✓ Can handle 'o' with count (188ms)

    ✓ Can handle 'O' with count (200ms)



  Mode Normal

    ✓ Can be activated (84ms)

    ✓ Can handle dw (148ms)

    ✓ Can handle dw (80ms)

    ✓ Can handle dw (109ms)

    ✓ Can handle dw across lines (1) (217ms)

    ✓ Can handle dw across lines (2) (92ms)

    ✓ Can handle dd last line (65ms)

    ✓ Can handle dd single line (92ms)

    ✓ Can handle dd (74ms)

    ✓ Can handle 3dd (75ms)

    ✓ Can handle 3dd off end of document (86ms)

    ✓ Can handle d2d (99ms)

    ✓ Can handle dd empty line (71ms)

    ✓ Can handle ddp (220ms)

    ✓ Can handle 'de' (178ms)

    ✓ Can handle 'de' then 'de' again (195ms)

    ✓ Can handle 'db' (181ms)

    ✓ Can handle 'db then 'db' again (116ms)

    1) Can handle 'dl' at end of line

    ✓ Can handle 'dF' (117ms)

    ✓ Can handle 'dT' (177ms)

    ✓ Can handle 'd3' then <enter> (85ms)

    ✓ Can handle 'dj' (99ms)

    ✓ Can handle 'dk' (88ms)

    ✓ Can handle 'd])' without deleting closing parenthesis (97ms)

    ✓ Can handle 'd]}' without deleting closing bracket (80ms)

    ✓ Can handle 'cw' (231ms)

    ✓ Can handle 'cw' without deleting following white spaces (44ms)

    ✓ Can handle 'c2w' (103ms)

    ✓ Can handle 'cw' without removing EOL (121ms)

    ✓ Can handle 'c])' without deleting closing parenthesis (175ms)

    ✓ Can handle 'c]}' without deleting closing bracket (151ms)

    ✓ Can handle 's' (95ms)

    ✓ Can handle 'yiw' with correct cursor ending position (169ms)

    ✓ Can handle 'ciw' (147ms)

    ✓ Can handle 'ciw' on blanks (161ms)

    ✓ Can handle 'caw' (151ms)

    ✓ Can handle 'caw' on first letter (157ms)

    ✓ Can handle 'caw' on blanks (179ms)

    ✓ Can handle 'caw' on blanks (132ms)

    ✓ Can handle 'ci(' on first parentheses (141ms)

    ✓ Can handle 'ci(' with nested parentheses (104ms)

    ✓ Can handle 'ci(' backwards through nested parens (131ms)

    ✓ Can handle 'cib' on first parentheses (83ms)

    ✓ Can handle 'ci(' across multiple lines with last character at beginning (85ms)

    ✓ Can handle 'ca(' spanning multiple lines (82ms)

    ✓ Can handle 'cab' spanning multiple lines (244ms)

    ✓ Can handle 'ci{' spanning multiple lines (64ms)

    ✓ Can handle 'ci{' spanning multiple lines and handle whitespaces correctly (95ms)

    ✓ Can handle 'ci{' spanning multiple lines and handle whitespaces correctly (87ms)

    ✓ Can handle 'ci(' on the closing bracket (173ms)

    ✓ Can handle 'ciB' spanning multiple lines (92ms)

    ✓ will fail when ca( with no () (81ms)

    ✓ will fail when ca{ with no {} (57ms)

    ✓ will fail when caB with no {} (57ms)

    ✓ Can handle 'ci[' spanning multiple lines (82ms)

    ✓ Can handle 'ci]' on first bracket (140ms)

    ✓ Can handle 'ca[' on first bracket (57ms)

    ✓ Can handle 'ca]' on first bracket (106ms)

    ✓ Can handle 'ci'' on first quote (55ms)

    ✓ Can handle 'ci'' inside quoted string (96ms)

    ✓ Can handle 'ci'' on closing quote (106ms)

    ✓ Can handle 'ci'' when string is ahead (85ms)

    ✓ Can handle 'ci"' on opening quote (90ms)

    ✓ Can handle 'ci"' starting behind the quoted word (87ms)

    ✓ Can handle 'ca"' starting behind the quoted word (46ms)

    ✓ Can handle 'ca"' starting on the opening quote (88ms)

    ✓ Can handle 'ci"' with escaped quotes (127ms)

    ✓ Can handle 'ci"' with a single escaped quote (65ms)

    ✓ Can handle 'ci"' with a single escaped quote behind (136ms)

    ✓ Can handle 'ci"' with an escaped backslash (91ms)

    ✓ Can handle 'ci"' with an escaped backslash on closing quote (187ms)

    ✓ Can handle 'ca"' starting on the closing quote (122ms)

    ✓ Can handle 'ci"' with complex escape sequences (108ms)

    ✓ Can pick the correct open quote between two strings for 'ci"' (84ms)

    ✓ will fail when ca" ahead of quoted string (82ms)

    ✓ Can handle 'ca`' inside word (138ms)

    ✓ Can handle 'daw' on word with cursor inside spaces (119ms)

    ✓ Can handle 'daw' on word with trailing spaces (102ms)

    ✓ Can handle 'daw' on word with leading spaces (126ms)

    ✓ Can handle 'daw' on word with numeric prefix (108ms)

    ✓ Can handle 'daw' on word with numeric prefix and across lines (216ms)

    ✓ Can handle 'daw' on word with numeric prefix and across lines (164ms)

    ✓ Can handle 'daw' on word with numeric prefix and across lines, containing words end with `.` (125ms)

    ✓ Can handle 'daw' on end of word (193ms)

    ✓ Can handle 'daw' on words at beginning of line with leading whitespace (180ms)

    ✓ Can handle 'daw' on words at ends of lines in the middle of whitespace (148ms)

    ✓ Can handle 'daw' on word at beginning of file (78ms)

    ✓ Can handle 'daw' on word at beginning of line (82ms)

    ✓ Can handle 'daw' on word at end of line with trailing whitespace (177ms)

    ✓ Can handle 'daw' around word at end of line (142ms)

    ✓ Can handle 'daW' on big word with cursor inside spaces (142ms)

    ✓ Can handle 'daW' around word at whitespace (138ms)

    ✓ Can handle 'daW' on word with trailing spaces (107ms)

    ✓ Can handle 'daW' on word with leading spaces (158ms)

    ✓ Can handle 'daW' on word with numeric prefix (57ms)

    ✓ Can handle 'daW' on word with numeric prefix and across lines (150ms)

    ✓ Can handle 'daW' on beginning of word (85ms)

    ✓ Can handle 'daW' on end of one line (107ms)

    ✓ Can handle 'daW' around word at the last WORD (t|wo) (103ms)

    ✓ Can handle 'daW' around word at the last WORD (tw|o) (122ms)

    ✓ Can handle 'daW' around word at the last WORD (class="btn"|>) (127ms)

    ✓ Can handle 'daW' around word at the last WORD of the end of document (class="btn"|>) (156ms)

    ✓ Can handle 'daW' around word at the last WORD (c|lass="btn">) (134ms)

    ✓ Can handle 'daW' around word at the last WORD of the end of document (c|lass="btn">) (124ms)

    ✓ Can handle 'diw' on word with cursor inside spaces (102ms)

    ✓ Can handle 'diw' on word (127ms)

    ✓ Can handle 'diw' on word with numeric prefix (125ms)

    ✓ Can handle 'diw' on trailing spaces at the end of line (369ms)

    ✓ Can handle 'diw' on word with numeric prefix and across lines (218ms)

    ✓ Can handle 'diw' on word with numeric prefix and across lines, containing words end with `.` (166ms)

    ✓ Can handle 'diW' on big word with cursor inside spaces (153ms)

    ✓ Can handle 'diW' on word with trailing spaces (153ms)

    ✓ Can handle 'diW' on word with leading spaces (187ms)

    ✓ Can handle 'diW' on word with numeric prefix (120ms)

    ✓ Can handle 'diW' on word with numeric prefix and across lines (203ms)

    ✓ Can handle 'diW' on beginning of word (121ms)

    ✓ Can handle d} (58ms)

    ✓ Can handle y} at beginning of line (62ms)

    ✓ Select sentence with trailing spaces (175ms)

    ✓ Select sentence with leading spaces (246ms)

    ✓ Select inner sentence with trailing spaces (160ms)

    ✓ Select inner sentence with leading spaces (279ms)

    ✓ Select spaces between sentences (313ms)

    ✓ Can handle 'df' (283ms)

    ✓ Can handle 'dt' (134ms)

    ✓ Can handle backspace (133ms)

    ✓ Can handle backspace across lines (76ms)

    ✓ Can handle A and backspace (64ms)

    ✓ Can handle 'yy' without changing cursor position (65ms)

    ✓ Can handle 'P' after 'yy' (102ms)

    ✓ Can handle 'p' after 'yy' (88ms)

    ✓ Can handle 'P' after 'Nyy' (83ms)

    ✓ Can handle 'p' after 'Nyy' (109ms)

    ✓ Can handle 'p' after 'yy' with correct cursor position (92ms)

    ✓ Can handle 'gp' after 'yy' (98ms)

    ✓ Can handle 'gp' after 'Nyy' (121ms)

    ✓ Can handle 'gp' after 'Nyy' if cursor is on the last line (152ms)

    ✓ Can handle 'gP' after 'yy' (114ms)

    ✓ Can handle 'gP' after 'Nyy' (67ms)

    ✓ Can handle ']p' after yy (85ms)

    ✓ Can handle ']p' after 'Nyy' (63ms)

    2) Can handle ']p' after 'Nyy' and indent with tabs first

    3) Can handle ']p' after 'Nyy' and decrease indents if possible

    ✓ Can handle '[p' after yy (93ms)

    ✓ Can handle '[p' after 'Nyy' (197ms)

    4) Can handle '[p' after 'Nyy' and indent with tabs first

    ✓ Can handle '[p' after 'Nyy' and decrease indents if possible (134ms)

    ✓ Can handle 'p' after y'a (183ms)

    ✓ Can handle 'p' after 'y])' without including closing parenthesis (108ms)

    ✓ Can handle 'p' after 'y]}' without including closing bracket (101ms)

    ✓ Can handle pasting in visual mode over selection (171ms)

    ✓ Can repeat w (57ms)

    ✓ Can repeat p (47ms)

    ✓ I works correctly (162ms)

    ✓ gI works correctly (87ms)

    ✓ gi works correctly (113ms)

    ✓ `. works correctly (110ms)

    ✓ '. works correctly (106ms)

    ✓ g; works correctly (141ms)

    ✓ g, works correctly (142ms)

    ✓ g_ works correctly (101ms)

    ✓ 3g_ works correctly (76ms)

    ✓ Can handle space

    ✓ Can handle space (47ms)

    ✓ Undo 1 (144ms)

    ✓ Undo 2 (104ms)

    ✓ Undo cursor (260ms)

    ✓ Undo cursor 2 (200ms)

    ✓ Undo cursor 3 (206ms)

    ✓ Undo with movement first (144ms)

    ✓ Can handle 'U' (103ms)

    ✓ Can handle 'U' for multiple changes (224ms)

    ✓ Can handle 'U' for new line below (102ms)

    ✓ Can handle 'U' for new line above (139ms)

    ✓ Can handle 'U' for consecutive changes only (148ms)

    ✓ Can handle 'u' to undo 'U' (89ms)

    ✓ Can handle 'U' to undo 'U' (72ms)

    ✓ Redo (158ms)

    ✓ Redo (205ms)

    ✓ Redo (344ms)

    ✓ Can handle u (121ms)

    ✓ Can handle guw (68ms)

    ✓ Can handle gUw (65ms)

    ✓ Can handle u over line breaks (59ms)

    ✓ can handle s in visual mode (101ms)

    ✓ can handle p with selection (63ms)

    ✓ can handle P with selection (70ms)

    5) can handle p in visual to end of line

    ✓ can repeat backspace twice (130ms)

    ✓ can delete linewise with d2G (90ms)

    ✓ can delete with + motion and count (116ms)

    ✓ can delete with - motion and count (161ms)

    ✓ can dE correctly (76ms)

    ✓ can dE correctly (56ms)

    ✓ can dE correctly (106ms)

    ✓ can ctrl-a correctly behind a word (74ms)

    ✓ can ctrl-a the right word (always the one AFTER the cursor) (49ms)

    ✓ can ctrl-a on word (88ms)

    ✓ can ctrl-a on a hex number (68ms)

    ✓ can ctrl-a on decimal (75ms)

    ✓ can ctrl-a with numeric prefix (100ms)

    ✓ can ctrl-a on a decimal (98ms)

    ✓ can ctrl-a on an octal  (74ms)

    ✓ Correctly increments in the middle of a number (63ms)

    ✓ can ctrl-x correctly behind a word (44ms)

    ✓ can ctrl-a on an number with word before  (116ms)

    ✓ can ctrl-a on an number with word before and after  (47ms)

    ✓ can ctrl-x on a negative number with word before and after  (58ms)

    ✓ can ctrl-a properly on multiple lines (101ms)

    ✓ can <C-a> on word with multiple numbers (incrementing first number) (64ms)

    ✓ can <C-a> on word with multiple numbers (incrementing second number) (59ms)

    ✓ can do Y (47ms)

    6) Can do S

    ✓ / does not affect mark (145ms)

    ✓ / can search with regex (167ms)

    ✓ / can search with newline (117ms)

    ✓ / can search through multiple newlines (182ms)

    ✓ / matches ^ per line (115ms)

    ✓ / matches $ per line (97ms)

    ✓ /\c forces case insensitive search (78ms)

    ✓ /\C forces case sensitive search (182ms)

    ✓ <BS> deletes the last character in search in progress mode (137ms)

    ✓ <S-BS> deletes the last character in search in progress mode (74ms)

    ✓ <C-h> deletes the last character in search in progress mode (121ms)

    ✓ Can do C (75ms)

    ✓ Can do cit on a matching tag (111ms)

    ✓ Ignores cit on a non-matching tag (116ms)

    ✓ Ignores cit on a nested tag (165ms)

    ✓ Can do cit on a tag with an attribute tag (149ms)

    ✓ Can do cat on a matching tag (267ms)

    ✓ Can do cit on a multiline tag (134ms)

    ✓ Can do cit on a multiline tag with nested tags (190ms)

    ✓ Can do cit inside of a tag with another non closing tag inside tags (262ms)

    ✓ Can do cit inside of a tag with another empty closing tag inside tags (136ms)

    ✓ Can do dit on empty tag block, cursor moves to inside (75ms)

    ✓ Can do cit on empty tag block, cursor moves to inside (112ms)

    ✓ can do cit with self closing tags (215ms)

    ✓ Respects indentation with cc (127ms)

    ✓ Resets cursor to indent end with cc (95ms)

    ✓ can handle 'cc' on empty line (164ms)

    ✓ cc copies linewise (102ms)

    ✓ Indent current line with correct Vim Mode (74ms)

    ✓ Can handle <Esc> and do nothing (57ms)

    ✓ Can handle # on consecutive words (166ms)

    ✓ Can handle # on skipped words (179ms)

    ✓ Can 'D'elete the characters under the cursor until the end of the line (332ms)

    ✓ Can 'D'elete the characters under multiple cursors until the end of the line (370ms)

    ✓ cc on whitespace-only treats whitespace as indent (77ms)

    ✓ Can do cai (306ms)

    ✓ Can do cii (84ms)

    ✓ Can do caI (194ms)

    ✓ Can do dai (176ms)

    ✓ Can do dii (78ms)

    ✓ Can do daI (192ms)

    can handle gn

      ✓ gn selects the next match text (395ms)

      ✓ gn selects the current word at |hello (467ms)

      ✓ gn selects the current word at h|ello (350ms)

      ✓ gn selects the current word at hel|lo (325ms)

      ✓ gn selects the current word at hell|o (379ms)

      ✓ gn selects the next word at hello| (337ms)

    can handle dgn

      ✓ dgn deletes the next match text (from first line) (136ms)

      ✓ dgn deletes the current word when cursor is at |hello (90ms)

      ✓ dgn deletes the current word when cursor is at h|ello (109ms)

      ✓ dgn deletes the current word when cursor is at hel|lo (86ms)

      ✓ dgn deletes the current word when cursor is at hell|o (92ms)

      ✓ dgn deletes the next word when cursor is at hello| (88ms)

    can handle cgn

      ✓ cgn deletes the next match text (from first line) (101ms)

      ✓ cgn deletes the current word when cursor is at |hello (66ms)

      ✓ cgn deletes the current word when cursor is at h|ello (103ms)

      ✓ cgn deletes the current word when cursor is at hel|lo (159ms)

      ✓ cgn deletes the current word when cursor is at hell|o (119ms)

      ✓ cgn deletes the next word when cursor is at hello| (103ms)

    can handle gN

      ✓ gN selects the previous match text (571ms)

      ✓ gN selects the current word at hell|o (584ms)

      ✓ gN selects the current word at hel|lo (290ms)

      ✓ gN selects the current word at h|ello (344ms)

      ✓ gN selects the current word at |hello (442ms)

      ✓ gN selects the previous word at | hello (457ms)

    can handle dgN

      ✓ dgN deletes the previous match text (from first line) (130ms)

      ✓ dgN deletes the current word when cursor is at hell|o (124ms)

      ✓ dgN deletes the current word when cursor is at hel|lo (120ms)

      ✓ dgN deletes the current word when cursor is at h|ello (165ms)

      ✓ dgN deletes the current word when cursor is at |hello (119ms)

      ✓ dgN deletes the previous word when cursor is at | hello (101ms)

    can handle cgN

      ✓ cgN deletes the previous match text (from first line) (133ms)

      ✓ cgN deletes the current word when cursor is at hell|o (113ms)

      ✓ cgN deletes the current word when cursor is at hel|lo (293ms)

      ✓ cgN deletes the current word when cursor is at h|ello (244ms)

      ✓ cgN deletes the current word when cursor is at |hello (187ms)

      ✓ cgN deletes the previous word when cursor is at | hello (178ms)



  Mode Replace

    ✓ Can activate with <insert> from Insert mode (70ms)

    ✓ Can activate with R from Normal mode (67ms)

    ✓ Can handle R (94ms)

    ✓ Can handle R past current line (128ms)

    ✓ Can handle R and exit Replace Mode (122ms)

    ✓ Can handle R across lines (172ms)

    ✓ Can handle R across lines and exit Replace Mode (246ms)

    ✓ Can handle R with {count} (175ms)

    ✓ Can handle backspace (157ms)

    ✓ Can handle backspace (208ms)

    ✓ Can handle backspace across lines (331ms)

    ✓ Can handle arrows (247ms)

    ✓ Can handle . (204ms)

    ✓ Can handle . across lines (224ms)



  Mode Visual

    ✓ can be activated

    ✓ Can handle w (250ms)

    ✓ Can handle wd (298ms)

    ✓ Can handle x (317ms)

    ✓ Can handle x across a selection (188ms)

    ✓ Can do vwd in middle of sentence (492ms)

    ✓ Can do vwd in middle of sentence (374ms)

    ✓ Can do vwd multiple times (474ms)

    ✓ handles case where we go from selecting on right side to selecting on left side (211ms)

    ✓ Can handle H key (84ms)

    ✓ handles case where we delete over a newline (303ms)

    ✓ handles change operator (350ms)

    ✓ Can do vi) on a matching parenthesis (223ms)

    ✓ Can do va) on a matching parenthesis (249ms)

    ✓ Can do va} on a matching bracket as first character (117ms)

    ✓ Can do vi( on a matching bracket near first character (107ms)

    ✓ Can do vi{ on outer pair of nested braces (181ms)

    ✓ Can do vi{ on braces indented by 1 and preserve indent (178ms)

    ✓ Can use . to repeat indent in visual (141ms)

    ✓ Can do v_x to delete to first char (236ms)

    ✓ Can do vg_x to delete to last char with no EOL (333ms)

    ✓ Can do v3g_x to delete to last char with no EOL with count (189ms)

    ✓ Can do v$x to delete to last char including EOL (152ms)

    ✓ Can do gv to reselect previous selection (245ms)

    Vim's EOL handling is weird

      7) delete through eol

      8) join 2 lines by deleting through eol

      ✓ d$ doesn't delete whole line (264ms)

      ✓ vd$ does delete whole line (194ms)

      ✓ Paste over selection copies the selection (249ms)

      ✓ Paste over selection copies the selection linewise (247ms)

    Arrow keys work perfectly in Visual Mode

      ✓ Can handle <up> key (174ms)

      ✓ Can handle <down> key (175ms)

      ✓ Can handle <left> key (121ms)

      ✓ Can handle <right> key (119ms)

    handles aw in visual mode

      ✓ Can handle 'vawd' on word with cursor inside spaces (204ms)

      ✓ Can handle 'vawd' on word with trailing spaces (131ms)

      ✓ Can handle 'vawd' on word with leading spaces (277ms)

      ✓ Can handle 'vawd' on word with numeric prefix (120ms)

      ✓ Can handle 'vawd' on word with numeric prefix and across lines (281ms)

      ✓ Can handle 'vawd' on word with numeric prefix and across lines, containing words end with `.` (280ms)

    handles aW in visual mode

      ✓ Can handle 'vaWd' on big word with cursor inside spaces (163ms)

      ✓ Can handle 'vaWd' on word with trailing spaces (316ms)

      ✓ Can handle 'vaWd' on word with leading spaces (179ms)

      ✓ Can handle 'vaWd' on word with numeric prefix (104ms)

      ✓ Can handle 'vaWd' on word with numeric prefix and across lines (278ms)

    handles aW in visual mode

      ✓ Can handle 'vaWd' on big word with cursor inside spaces (167ms)

      ✓ Can handle 'vaWd' on word with trailing spaces (160ms)

      ✓ Can handle 'vaWd' on word with leading spaces (161ms)

      ✓ Can handle 'vaWd' on word with numeric prefix (86ms)

      ✓ Can handle 'vaWd' on word with numeric prefix and across lines (220ms)

    handles aw in visual mode

      ✓ Can handle 'vawd' on word with cursor inside spaces (129ms)

      ✓ Can handle 'vawd' on word with trailing spaces (87ms)

      ✓ Can handle 'vawd' on word with leading spaces (212ms)

      ✓ Can handle 'vawd' on word with numeric prefix (174ms)

      ✓ Can handle 'vawd' on word with numeric prefix and across lines (181ms)

      ✓ Can handle 'vawd' on word with numeric prefix and across lines, containing words end with `.` (111ms)

    handles aW in visual mode

      ✓ Can handle 'vaWd' on big word with cursor inside spaces (157ms)

      ✓ Can handle 'vaWd' on word with trailing spaces (270ms)

      ✓ Can handle 'vaWd' on word with leading spaces (126ms)

      ✓ Can handle 'vaWd' on word with numeric prefix (88ms)

      ✓ Can handle 'vaWd' on word with numeric prefix and across lines (208ms)

      ✓ Can handle 'Y' in visual mode (116ms)

    handles as in visual mode

      ✓ Select sentence with trailing spaces in visual mode (232ms)

      ✓ Select sentence with leading spaces in visual mode (263ms)

      ✓ Select multiple sentences in visual mode (329ms)

    handles is in visual mode

      ✓ Select inner sentence with trailing spaces in visual mode (178ms)

      ✓ Select inner sentence with leading spaces in visual mode (412ms)

      ✓ Select spaces between sentences in visual mode (575ms)

    handles tag blocks in visual mode

      ✓ Can do vit on a matching tag (227ms)

      ✓ Can do vat on a matching tag (365ms)

    handles replace in visual mode

      ✓ Can do a single line replace (156ms)

      ✓ Can do a multi line replace (161ms)

    D command will remove all selected lines

      ✓ D deletes all selected lines (346ms)

      ✓ D deletes the current line (97ms)

    handles indent blocks in visual mode

      ✓ Can do vai (208ms)

      ✓ Can do vii (162ms)

      9) Doesn't naively select the next line

      ✓ Searches backwards if cursor line is empty (127ms)

      ✓ Can do vaI (228ms)

    visualstar

      ✓ Works with * (95ms)

      ✓ Works with # (79ms)

    search works in visual mode

      ✓ Works with / (198ms)

      ✓ Works with ? (227ms)

      ✓ Selects correct range (409ms)

    X will delete linewise

      ✓ normal selection (112ms)

      ✓ normal selection (226ms)

    C will delete linewise

      ✓ normal selection (171ms)

      ✓ normal selection (172ms)

    R will delete linewise

      ✓ normal selection (137ms)

      ✓ normal selection (127ms)

    Linewise Registers will be inserted properly

      ✓ downward selection (292ms)

      ✓ upward selection (339ms)

    Indent Tests using > on visual selections

      ✓ multiline indent top down selection (181ms)

      ✓ multiline indent bottom up selection (353ms)

      ✓ repeat multiline indent top down selection (364ms)

      ✓ repeat multiline indent bottom up selection (170ms)

    Outdent Tests using < on visual selections

      10) multiline outdent top down selection

      11) multiline outdent bottom up selection

      12) repeat multiline outdent top down selection

      13) repeat multiline outdent bottom up selection

    Non-darwin <C-c> tests

      ✓ <C-c> copies and sets mode to normal (435ms)

    vi{ will go to end of second to last line

      ✓ select (316ms)

    Transition between visual mode

      ✓ vv will back to normal mode

      ✓ vV will transit to visual line mode

      ✓ v<C-v> will transit to visual block mode

      ✓ Vv will transit to visual (char) mode

      ✓ VV will back to normal mode

      ✓ V<C-v> will transit to visual block mode

      ✓ <C-v>v will transit to visual (char) mode

      ✓ <C-v>V will back to visual line mode

      ✓ <C-v><C-v> will back to normal mode (38ms)

    replace text in characterwise visual-mode with characterwise register content

      ✓ gv selects the last pasted text (which is shorter than original) (799ms)

      ✓ gv selects the last pasted text (which is longer than original) (990ms)

      ✓ gv selects the last pasted text (multiline) (538ms)

    can handle gn

      ✓ gn selects the next match text (759ms)

      ✓ gn selects the current word at |hello (490ms)

      ✓ gn selects the current word at h|ello (653ms)

      ✓ gn selects the current word at hel|lo (559ms)

      ✓ gn selects the next word at hell|o (507ms)

      ✓ gn selects the next word at hello| (538ms)



  Mode Visual Block

    ✓ can be activated

    ✓ Can handle A forward select (175ms)

    ✓ Can handle A backwards select (129ms)

    ✓ Can handle I forward select (189ms)

    ✓ Can handle I backwards select (267ms)

    ✓ Can handle I with empty lines on first character (inserts on empty line) (224ms)

    ✓ Can handle I with empty lines on non-first character (does not insert on empty line) (163ms)

    ✓ Can handle c forward select (222ms)

    ✓ Can handle c backwards select (237ms)

    ✓ Can handle C (279ms)

    ✓ Can do a multi line replace (194ms)

    ✓ Can handle 'D' (239ms)

    ✓ Can handle 'gj' (167ms)

    ✓ Properly add to end of lines j then $ (166ms)

    ✓ Properly add to end of lines $ then j (170ms)

    ✓ o works in visual block mode (157ms)

    Non-darwin <C-c> tests

      ✓ <C-c> copies and sets mode to normal (478ms)


  Mode Visual Line

    ✓ can be activated

    ✓ Can handle w (354ms)

    ✓ Can handle wd (253ms)

    ✓ Can handle x (246ms)

    ✓ Can handle U (218ms)

    ✓ Can handle x across a selection (290ms)

    ✓ Can do vwd in middle of sentence (493ms)

    ✓ Can do vwd in middle of sentence (299ms)

    ✓ Can do vwd multiple times (418ms)

    ✓ Can handle U across a selection (231ms)

    ✓ Can handle U across a selection in reverse order (216ms)

    ✓ handles case where we go from selecting on right side to selecting on left side (312ms)

    ✓ handles case where we delete over a newline (314ms)

    ✓ handles change operator (304ms)

    ✓ Vp updates register content (158ms)

    ✓ Vp does not append unnecessary newlines (first line) (302ms)

    ✓ Vp does not append unnecessary newlines (middle line) (105ms)

    ✓ Vp does not append unnecessary newlines (last line) (187ms)

    Vim's EOL handling is weird

      14) delete through eol

      15) join 2 lines by deleting through eol

      ✓ d$ doesn't delete whole line (108ms)

      ✓ vd$ does delete whole line (196ms)

    Arrow keys work perfectly in Visual Line Mode

      ✓ Can handle <up> key (88ms)

      ✓ Can handle <down> key (192ms)

    Can handle d/c correctly in Visual Line Mode

      ✓ Can handle d key (56ms)

      ✓ Can handle d key (115ms)

      ✓ Can handle d key (197ms)

      ✓ Can handle d key (186ms)

      ✓ can handle 'c' (168ms)

    handles replace in visual line mode

      ✓ Can do a single line replace (114ms)

      ✓ Can do a multi visual line replace (110ms)

      ✓ Can do a multi visual line replace from the bottom up (105ms)

    search works in visual line mode

      ✓ Works with / (178ms)

      ✓ Works with ? (125ms)

    Non-darwin <C-c> tests

      ✓ <C-c> copies and sets mode to normal (402ms)

    replace text in linewise visual-mode with linewise register content

      ✓ yyVp does not change the content but changes cursor position (101ms)

      ✓ linewise visual put works also in the end of document (115ms)

      ✓ gv selects the last pasted text (which is shorter than original) (852ms)

      ✓ gv selects the last pasted text (which is longer than original) (767ms)

      ✓ gv selects the last pasted text (multiline) (543ms)



  Mode Normal

    ✓ Can handle 'x' (109ms)

    ✓ Can handle 'Nx' (84ms)

    ✓ Can handle 'Nx' and paste (180ms)

    ✓ Can handle 'x' at end of line (293ms)

    ✓ Can handle 'Ns' (114ms)

    ✓ Can handle 'Ns' at end of line (112ms)

    ✓ Can handle '<Del>' (103ms)

    ✓ Can handle '<Del>' with counts, which removes the last character of the count (106ms)

    ✓ Can handle '<Del>' at end of line (147ms)

    ✓ Can handle 'cc' (77ms)

    ✓ Can handle 'Ncc' (63ms)

    ✓ Can handle 'yy' (55ms)

    ✓ Can handle 'D' (207ms)

    ✓ Can handle 'D' on empty lines (78ms)

    ✓ Can handle 'DD' (107ms)

    ✓ Can handle 'C' (136ms)

    ✓ Can handle 'NC' (118ms)

    ✓ Can handle 'r' (326ms)

    ✓ Can handle '<Count>r' (65ms)

    ✓ Can handle '<Count>r' (63ms)

    ✓ Can handle 'r' after 'dd' (121ms)

    ✓ Can handle 'J' once (70ms)

    ✓ Can handle 'J' twice (188ms)

    ✓ Can handle 'J' with empty last line (93ms)

    ✓ Can handle 'J's with multiple empty last lines (261ms)

    ✓ Can handle 'J' with leading white space on next line (135ms)

    ✓ Can handle 'J' with only white space on next line (102ms)

    ✓ Can handle 'J' with TWO indented lines (119ms)

    ✓ Can handle 'J' with ')' first character on next line (167ms)

    ✓ Can handle 'J' with a following delete (102ms)

    ✓ Can handle 'J' in Visual Line mode (89ms)

    ✓ Can handle 'gJ' once (63ms)

    ✓ Can handle 'gJ' once and ALL WHITESPACE IS ELIMINATED (88ms)

    ✓ Can handle '~' (61ms)

    ✓ Can handle 'g~{motion}' (78ms)

    ✓ Can handle '<BS>' in insert mode (79ms)

    ✓ Can handle undo with P (174ms)



  Dot Operator

    ✓ Can repeat '~' with <num> (95ms)

    ✓ Can repeat '~' with dot (138ms)

    ✓ Can repeat 'x' (73ms)

    ✓ Can repeat 'J' (114ms)

    ✓ Can handle dot with A (107ms)

    ✓ Can handle dot with I (175ms)

    ✓ Can repeat actions that require selections (147ms)



  Repeat content change

    16) Can repeat '<C-t>'

    17) Can repeat insert change and '<C-t>'

    18) Can repeat change by `<C-a>`

    ✓ Only one arrow key can be repeated in Insert Mode (118ms)

    19) Cached content change will be cleared by arrow keys



  Matching Bracket (%)

    ✓ before opening parenthesis (95ms)

    ✓ inside parenthesis (105ms)

    ✓ nested parenthesis beginning (59ms)

    ✓ nested parenthesis end (76ms)

    ✓ nested bracket and parenthesis beginning (61ms)

    ✓ nested bracket, parenthesis, braces beginning (54ms)

    ✓ nested bracket, parenthesis, braces end (148ms)



  Motions in Normal Mode

    ✓ Can handle [( (93ms)

    ✓ Can handle nested [( (78ms)

    ✓ Can handle <number>[( (75ms)

    ✓ Can handle [( and character under cursor exclusive (48ms)

    ✓ Can handle ]) (86ms)

    ✓ Can handle nested ]) (78ms)

    ✓ Can handle <number>]) (58ms)

    ✓ Can handle ]) and character under cursor exclusive (80ms)

    ✓ Can handle [{ (98ms)

    ✓ Can handle nested [{ (94ms)

    ✓ Can handle <number>[{ (63ms)

    ✓ Can handle [{ and character under cursor exclusive (55ms)

    ✓ Can handle ]} (59ms)

    ✓ Can handle nested ]} (235ms)

    ✓ Can handle <number>]} (79ms)

    ✓ Can handle ]} and character under cursor exclusive (79ms)

    ✓ Can handle 'ge' (126ms)

    ✓ Can handle 'gg' (96ms)

    ✓ Can handle 'gg' to first non blank char on random line (63ms)

    ✓ Can handle 'gg' to first non blank char on first line (109ms)

    ✓ Retain same column when moving up/down (114ms)

    ✓ Can handle <enter> (72ms)

    ✓ $ always keeps cursor on EOL (124ms)

    ✓ Can handle $ with a count (85ms)

    ✓ Can handle $ with a count at end of file (89ms)

    ✓ Can handle <end> with a count (82ms)

    ✓ Can handle <D-right> with a count (91ms)

    ✓ Can handle 'f' (90ms)

    ✓ Can handle 'f' twice (198ms)

    ✓ Can handle 'F' (237ms)

    ✓ Can handle 'F' twice (197ms)

    ✓ Can handle 't' (121ms)

    ✓ Can handle 't' twice (121ms)

    ✓ Can handle 'T' (212ms)

    ✓ Can handle 'T' twice (428ms)

    ✓ Can run a forward search (96ms)

    ✓ Can run a forward and find next search (145ms)

    ✓ Can run a reverse search (240ms)

    ✓ Can run a reverse and find next search (284ms)

    ✓ maintains column position correctly (150ms)

    ✓ maintains column position correctly with $ (134ms)

    ✓ Can handle G  (103ms)

    ✓ Can handle G with number prefix (100ms)

    ✓ Can handle G with number prefix (51ms)

    ✓ Can handle gg (85ms)

    ✓ Can handle gg with number prefix (46ms)

    ✓ Can handle 0 (94ms)

    ✓ Can handle 0 as part of a repeat (57ms)

    ✓ Can handle g* (53ms)

    ✓ Can handle g*n (48ms)

    ✓ Can handle * (39ms)

    ✓ Can handle ** (49ms)

    ✓ Can handle # on whitespace (107ms)

    ✓ Can handle # on EOL (231ms)

    ✓ Can handle g# (244ms)

    ✓ Can handle g#n (429ms)

    ✓ Can handle # (231ms)

    ✓ Can handle # already on the word (196ms)

    ✓ Can handle ## (318ms)

    ✓ Can handle | (282ms)

    ✓ Can handle <number> | (287ms)

    ✓ Can handle + (69ms)

    ✓ Can handle + indent (69ms)

    ✓ Can handle + with count prefix (95ms)

    ✓ Can handle - (118ms)

    ✓ Can handle - indent (110ms)

    ✓ Can handle - with count prefix (72ms)

    ✓ Can handle _ (72ms)

    ✓ Can handle _ with count prefix (72ms)

    ✓ Can handle g_ (105ms)

    ✓ Can handle g_ with count prefix (185ms)

    ✓ Can handle <up> key (107ms)

    ✓ Can handle <down> key (107ms)

    ✓ Can handle <left> key (107ms)

    ✓ Can handle <right> key (179ms)



  basic motion

    ✓ char right: should move one column right

    ✓ char right

    ✓ char left: should move cursor one column left

    ✓ char left: left-most column should stay at the same location

    ✓ line down: should move cursor one line down

    ✓ line down: bottom-most line should stay at the same location

    ✓ line begin

    ✓ line end

    ✓ document begin

    ✓ document end

    ✓ line begin cursor on first non-blank character

    ✓ last line begin cursor on first non-blank character

    line up

      ✓ should move cursor one line up

      ✓ top-most line should stay at the same location



  word motion

    ✓ line begin cursor on first non-blank character

    ✓ last line begin cursor on first non-blank character

    word right

      ✓ move to word right

      ✓ last word should move to next line

      ✓ last word should move to next line stops on empty line

      ✓ last word should move to next line skips whitespace only line

      ✓ last word on last line should go to end of document (special case!)

    word left

      ✓ move cursor word left across spaces

      ✓ move cursor word left within word

      ✓ first word should move to previous line, beginning of last word

      ✓ first word should move to previous line, stops on empty line

      ✓ first word should move to previous line, skips whitespace only line

    WORD right

      ✓ move to WORD right

      ✓ last WORD should move to next line

      ✓ last WORD should move to next line stops on empty line

      ✓ last WORD should move to next line skips whitespace only line

    WORD left

      ✓ move cursor WORD left across spaces

      ✓ move cursor WORD left within WORD

      ✓ first WORD should move to previous line, beginning of last WORD

      ✓ first WORD should move to previous line, stops on empty line

      ✓ first WORD should move to previous line, skips whitespace only line

    end of word right

      ✓ move to end of current word right

      ✓ move to end of next word right

      ✓ end of last word should move to next line

      ✓ end of last word should move to next line skips empty line

      ✓ end of last word should move to next line skips whitespace only line

    end of WORD right

      ✓ move to end of current WORD right

      ✓ move to end of next WORD right

      ✓ end of last WORD should move to next line

      ✓ end of last WORD should move to next line skips empty line

      ✓ end of last WORD should move to next line skips whitespace only line



  sentence motion

    sentence forward
      ✓ next concrete sentence
      ✓ next sentence that ends with paragraph ending
      ✓ next sentence when cursor is at the end of previous paragraph
      ✓ next sentence when paragraph contains a line of whilte spaces
    sentence backward
      ✓ current sentence begin
      ✓ sentence forward when cursor is at the beginning of the second sentence
      ✓ current sentence begin with no concrete sentense inside
      ✓ current sentence begin when it's not the same as current paragraph begin
      ✓ current sentence begin when previous line ends with a concrete sentence



  paragraph motion

    paragraph down

      ✓ move down normally

      ✓ move down longer paragraph

      ✓ move down starting inside empty line

      ✓ paragraph at end of document

    paragraph up

      ✓ move up short paragraph

      ✓ move up longer paragraph

      ✓ move up starting inside empty line



  motion line wrapping

    whichwrap enabled

      normal mode

        ✓ h wraps to previous line (65ms)

        ✓ l wraps to next line (309ms)

        ✓ <left> wraps to previous line (121ms)

        ✓ <right> wraps to next line (112ms)

      insert mode

        ✓ <left> wraps to previous line (147ms)

        ✓ <right> once goes to end of line (96ms)

        ✓ <right> twice wraps to next line (98ms)

    whichwrap disabled

      normal mode

        20) h does not wrap to previous line

        21) l does not wrap to next line

        22) <left> does not wrap to previous line

        23) <right> does not wrap to next line

      insert mode

        24) <left> does not wrap to previous line

        25) <right> does not wrap to next line



  Multicursor

    ✓ can add multiple cursors below (130ms)

    ✓ can add multiple cursors above (192ms)



  numeric string

    ✓ fails on non-string

    ✓ handles hex round trip

    ✓ handles decimal round trip

    ✓ handles octal trip



  comment operator

    ✓ gcc comments out current line (500ms)

    ✓ gcj comments in current and next line (272ms)

    ✓ block comment with motion (563ms)

    ✓ block comment in Visual Mode (211ms)



  put operator

    ✓ basic put test (337ms)

    ✓ test yy end of line (204ms)

    ✓ test yy first line (190ms)

    ✓ test yy middle line (252ms)

    ✓ test yy with correct positon movement (203ms)



  shift operator

    ✓ basic shift left test (345ms)

    ✓ shift left goto end test (241ms)

    ✓ shift left goto line test (203ms)

    ✓ shift right goto end test (123ms)

    ✓ shift right goto line test (80ms)



  easymotion plugin

    ✓ Can handle s move (125ms)

    ✓ Can handle 2s move (89ms)

    ✓ Can handle f move (114ms)

    ✓ Can handle 2f move (78ms)

    ✓ Can handle F move (217ms)

    ✓ Can handle 2F move (115ms)

    ✓ Can handle t move (104ms)

    ✓ Can handle bd-t move (169ms)

    ✓ Can handle 2t move (132ms)

    ✓ Can handle bd-t2 move (79ms)

    ✓ Can handle T move (111ms)

    ✓ Can handle 2T move (67ms)

    ✓ Can handle w move (129ms)

    ✓ Can handle bd-w move (152ms)

    ✓ Can handle b move (160ms)

    ✓ Can handle e move (193ms)

    ✓ Can handle bd-e move (214ms)

    ✓ Can handle ge move (231ms)

    ✓ Can handle n-char move (305ms)

    ✓ Can handle j move (148ms)

    ✓ Can handle k move (98ms)

    ✓ Can handle bd-jk move (1) (132ms)

    ✓ Can handle bd-jk move (2) (148ms)

    ✓ Can handle lineforward move (1) (78ms)

    ✓ Can handle lineforward move (2) (73ms)

    ✓ Can handle linebackward move (1) (240ms)

    ✓ Can handle linebackward move (2) (273ms)



  sneak plugin

    ✓ Can handle s motion (90ms)

    ✓ Can handle S motion (117ms)

    ✓ Can handle <operator>z motion (114ms)

    ✓ Can handle <operator>Z motion (160ms)

    ✓ Can handle s; motion (113ms)

    ✓ Can handle s, motion (129ms)

    ✓ Can handle S; motion (157ms)

    ✓ Can handle S, motion (115ms)



  surround plugin

    ✓ 'ysiw)' surrounds word without space (160ms)

    ✓ 'ysiw(' surrounds word with space (388ms)

    ✓ 'ysw)' surrounds word without space (291ms)

    ✓ 'ysw(' surrounds word with space (250ms)

    ✓ 'ysaw)' surrounds word without space (301ms)

    ✓ 'ysaw(' surrounds word with space (136ms)

    ✓ 'ysiw(' surrounds word with space and ignores punctuation (236ms)

    ✓ 'ysiw<' surrounds word with tags (216ms)

    ✓ 'ysiw<' surrounds word with tags and attributes (319ms)

    ✓ 'cst<' surrounds word with tags that have a dot in them (327ms)

    ✓ 'yss)' surrounds entire line respecting whitespace (178ms)

    ✓ change surround (222ms)

    ✓ change surround with alias (287ms)

    ✓ change surround to tags (193ms)

    ✓ delete surround (147ms)

    ✓ delete surround with alias (251ms)

    ✓ delete surround with tags (263ms)

    ✓ change surround brackets at end of line (210ms)

    ✓ changing brackets with surround works again (120ms)



  register

    ✓ Can copy to a register (335ms)

    ✓ Can use two registers together (221ms)

    ✓ Can use black hole register (181ms)

    ✓ System clipboard works with chinese characters (258ms)

    ✓ Yank stores text in Register '0' (376ms)

    ✓ Register '1'-'9' stores delete content (451ms)

    ✓ "A appends linewise text to "a (390ms)

    ✓ "A appends character wise text to "a (537ms)

    ✓ Can put and get to register

    clipboard

      ✓ Can access '*' (clipboard) register (171ms)

      ✓ Can access '+' (clipboard) register (192ms)



  Repeatable movements with f and t

    ✓ Can repeat f<character> (94ms)

    ✓ Can repeat reversed F<character> (85ms)

    ✓ Can repeat t<character> (100ms)

    ✓ Can repeat N times reversed t<character> (109ms)



  text editor

    ✓ insert 'Hello World'

    ✓ replace 'World' with 'Foo Bar'

    ✓ delete `Hello`

    ✓ delete the whole line

    ✓ try to read lines that don't exist





  923 passing (4m)

  25 failing



  1) Mode Normal
       Can handle 'dl' at end of line:

      Content does not match; Expected=b. Actual=blah.
      + expected - actual

      -blah
      +b
      
      at Suite.suite (test/mode/modeNormal.test.ts:159:3)


  2) Mode Normal
       Can handle ']p' after 'Nyy' and indent with tabs first:

      Content does not match; Expected=	two. Actual=    two.
      + expected - actual

      -    two
      +	two
      
      at Suite.suite (test/mode/modeNormal.test.ts:1114:3)


  3) Mode Normal
       Can handle ']p' after 'Nyy' and decrease indents if possible:

      Content does not match; Expected= one. Actual= two.
      + expected - actual

      - two
      + one
      
      at Suite.suite (test/mode/modeNormal.test.ts:1121:3)


  4) Mode Normal
       Can handle '[p' after 'Nyy' and indent with tabs first:

      Content does not match; Expected=	two. Actual=    two.
      + expected - actual

      -    two
      +	two
      
      at Suite.suite (test/mode/modeNormal.test.ts:1142:3)


  5) Mode Normal
       can handle p in visual to end of line:

      Content does not match; Expected=. Actual=t.
      + expected - actual

      -t
      
      at Suite.suite (test/mode/modeNormal.test.ts:1461:3)


  6) Mode Normal
       Can do S:

      Content does not match; Expected=    . Actual=    two.
      + expected - actual

      -    two
      +    
      
      at Suite.suite (test/mode/modeNormal.test.ts:1636:3)


  7) Mode Visual
       Vim's EOL handling is weird
         delete through eol:

      AssertionError: Content does not match; Expected=two. Actual=wo.
      + expected - actual

      -wo
      +two
      
      at Object.assertEqualLines (test/testUtils.ts:55:12)
      at Object.<anonymous> (test/mode/modeVisual.test.ts:157:7)
      at Generator.next (<anonymous>)
      at fulfilled (out/test/mode/modeVisual.test.js:4:58)
      at <anonymous>


  8) Mode Visual
       Vim's EOL handling is weird
         join 2 lines by deleting through eol:

      AssertionError: Content does not match; Expected=otwo. Actual=owo.
      + expected - actual

      -owo
      +otwo
      
      at Object.assertEqualLines (test/testUtils.ts:55:12)
      at Object.<anonymous> (test/mode/modeVisual.test.ts:165:7)
      at Generator.next (<anonymous>)
      at fulfilled (out/test/mode/modeVisual.test.js:4:58)
      at <anonymous>


  9) Mode Visual
       handles indent blocks in visual mode
         Doesn't naively select the next line:

      Content does not match; Expected=if foo > 3:. Actual=.
      + expected - actual

      +if foo > 3:
      
      at Suite.suite (test/mode/modeVisual.test.ts:684:5)


  10) Mode Visual
       Outdent Tests using < on visual selections
         multiline outdent top down selection:

      Content does not match; Expected=  222. Actual=    222.
      + expected - actual

      -    222
      +  222
      
      at Suite.suite (test/mode/modeVisual.test.ts:880:5)


  11) Mode Visual
       Outdent Tests using < on visual selections
         multiline outdent bottom up selection:

      Content does not match; Expected=  222. Actual=    222.
      + expected - actual

      -    222
      +  222
      
      at Suite.suite (test/mode/modeVisual.test.ts:887:5)


  12) Mode Visual
       Outdent Tests using < on visual selections
         repeat multiline outdent top down selection:

      Content does not match; Expected=222. Actual=    222.
      + expected - actual

      -    222
      +222
      
      at Suite.suite (test/mode/modeVisual.test.ts:894:5)


  13) Mode Visual
       Outdent Tests using < on visual selections
         repeat multiline outdent bottom up selection:

      Content does not match; Expected=222. Actual=    222.
      + expected - actual

      -    222
      +222
      
      at Suite.suite (test/mode/modeVisual.test.ts:901:5)


  14) Mode Visual Line
       Vim's EOL handling is weird
         delete through eol:

      AssertionError: Content does not match; Expected=two. Actual=wo.
      + expected - actual

      -wo
      +two
      
      at Object.assertEqualLines (test/testUtils.ts:55:12)
      at Object.<anonymous> (test/mode/modeVisualLine.test.ts:170:7)
      at Generator.next (<anonymous>)
      at fulfilled (out/test/mode/modeVisualLine.test.js:4:58)
      at <anonymous>


  15) Mode Visual Line
       Vim's EOL handling is weird
         join 2 lines by deleting through eol:

      AssertionError: Content does not match; Expected=otwo. Actual=owo.
      + expected - actual

      -owo
      +otwo
      
      at Object.assertEqualLines (test/testUtils.ts:55:12)
      at Object.<anonymous> (test/mode/modeVisualLine.test.ts:178:7)
      at Generator.next (<anonymous>)
      at fulfilled (out/test/mode/modeVisualLine.test.js:4:58)
      at <anonymous>


  16) Repeat content change
       Can repeat '<C-t>':

      Content does not match; Expected=	one. Actual=    one.
      + expected - actual

      -    one
      +	one
      
      at Suite.suite (test/mode/normalModeTests/dot.test.ts:81:3)


  17) Repeat content change
       Can repeat insert change and '<C-t>':

      Content does not match; Expected=	oneb. Actual=    oneb.
      + expected - actual

      -    oneb
      +	oneb
      
      at Suite.suite (test/mode/normalModeTests/dot.test.ts:88:3)


  18) Repeat content change
       Can repeat change by `<C-a>`:

      Content does not match; Expected=	oneb. Actual=    oneb.
      + expected - actual

      -    oneb
      +	oneb
      
      at Suite.suite (test/mode/normalModeTests/dot.test.ts:95:3)


  19) Repeat content change
       Cached content change will be cleared by arrow keys:

      Content does not match; Expected=	onecb. Actual=    onecb.
      + expected - actual

      -    onecb
      +	onecb
      
      at Suite.suite (test/mode/normalModeTests/dot.test.ts:109:3)


  20) motion line wrapping
       whichwrap disabled
         normal mode
           h does not wrap to previous line:

      Cursor LINE position is wrong.
      + expected - actual

      -0
      +1
      
      at Suite.suite (test/motionLineWrapping.test.ts:90:7)


  21) motion line wrapping
       whichwrap disabled
         normal mode
           l does not wrap to next line:

      Cursor LINE position is wrong.
      + expected - actual

      -1
      +0
      
      at Suite.suite (test/motionLineWrapping.test.ts:97:7)


  22) motion line wrapping
       whichwrap disabled
         normal mode
           <left> does not wrap to previous line:

      Cursor LINE position is wrong.
      + expected - actual

      -0
      +1
      
      at Suite.suite (test/motionLineWrapping.test.ts:104:7)


  23) motion line wrapping
       whichwrap disabled
         normal mode
           <right> does not wrap to next line:

      Cursor LINE position is wrong.
      + expected - actual

      -1
      +0
      
      at Suite.suite (test/motionLineWrapping.test.ts:111:7)


  24) motion line wrapping
       whichwrap disabled
         insert mode
           <left> does not wrap to previous line:

      Cursor LINE position is wrong.
      + expected - actual

      -0
      +1
      
      at Suite.suite (test/motionLineWrapping.test.ts:120:7)


  25) motion line wrapping
       whichwrap disabled
         insert mode
           <right> does not wrap to next line:

      Cursor LINE position is wrong.
      + expected - actual

      -1
      +0
      
      at Suite.suite (test/motionLineWrapping.test.ts:127:7)






Tests exited with code: 1