mirror of
				https://github.com/neovim/neovim.git
				synced 2025-11-03 17:24:29 +00:00 
			
		
		
		
	functests: Replace execute with either command or feed_command
Hope this will make people using feed_command less likely: this hides bugs. Already found at least two: 1. msgpackparse() will show internal error: hash_add() in case of duplicate keys, though it will still work correctly. Currently silenced. 2. ttimeoutlen was spelled incorrectly, resulting in option not being set when expected. Test was still functioning somehow though. Currently fixed.
This commit is contained in:
		@@ -5,7 +5,7 @@ local curbufmeths, ok = helpers.curbufmeths, helpers.ok
 | 
			
		||||
local funcs = helpers.funcs
 | 
			
		||||
local request = helpers.request
 | 
			
		||||
local exc_exec = helpers.exc_exec
 | 
			
		||||
local execute = helpers.execute
 | 
			
		||||
local feed_command = helpers.feed_command
 | 
			
		||||
local insert = helpers.insert
 | 
			
		||||
local NIL = helpers.NIL
 | 
			
		||||
local meth_pcall = helpers.meth_pcall
 | 
			
		||||
@@ -246,7 +246,7 @@ describe('api/buf', function()
 | 
			
		||||
    end)
 | 
			
		||||
 | 
			
		||||
    it("set_line on alternate buffer does not access invalid line (E315)", function()
 | 
			
		||||
      execute('set hidden')
 | 
			
		||||
      feed_command('set hidden')
 | 
			
		||||
      insert('Initial file')
 | 
			
		||||
      command('enew')
 | 
			
		||||
      insert([[
 | 
			
		||||
@@ -257,7 +257,7 @@ describe('api/buf', function()
 | 
			
		||||
      The
 | 
			
		||||
      Other
 | 
			
		||||
      Buffer]])
 | 
			
		||||
      execute('$')
 | 
			
		||||
      feed_command('$')
 | 
			
		||||
      local retval = exc_exec("call nvim_buf_set_lines(1, 0, 1, v:false, ['test'])")
 | 
			
		||||
      eq(0, retval)
 | 
			
		||||
    end)
 | 
			
		||||
 
 | 
			
		||||
@@ -1,6 +1,6 @@
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local eq, clear, eval, execute, nvim, next_message =
 | 
			
		||||
  helpers.eq, helpers.clear, helpers.eval, helpers.execute, helpers.nvim,
 | 
			
		||||
local eq, clear, eval, command, nvim, next_message =
 | 
			
		||||
  helpers.eq, helpers.clear, helpers.eval, helpers.command, helpers.nvim,
 | 
			
		||||
  helpers.next_message
 | 
			
		||||
local meths = helpers.meths
 | 
			
		||||
 | 
			
		||||
@@ -16,8 +16,8 @@ describe('notify', function()
 | 
			
		||||
    it('sends the notification/args to the corresponding channel', function()
 | 
			
		||||
      eval('rpcnotify('..channel..', "test-event", 1, 2, 3)')
 | 
			
		||||
      eq({'notification', 'test-event', {1, 2, 3}}, next_message())
 | 
			
		||||
      execute('au FileType lua call rpcnotify('..channel..', "lua!")')
 | 
			
		||||
      execute('set filetype=lua')
 | 
			
		||||
      command('au FileType lua call rpcnotify('..channel..', "lua!")')
 | 
			
		||||
      command('set filetype=lua')
 | 
			
		||||
      eq({'notification', 'lua!', {}}, next_message())
 | 
			
		||||
    end)
 | 
			
		||||
  end)
 | 
			
		||||
 
 | 
			
		||||
@@ -4,7 +4,7 @@ local clear = helpers.clear
 | 
			
		||||
local command = helpers.command
 | 
			
		||||
local eq = helpers.eq
 | 
			
		||||
local eval = helpers.eval
 | 
			
		||||
local execute = helpers.execute
 | 
			
		||||
local command = helpers.command
 | 
			
		||||
local request = helpers.request
 | 
			
		||||
local source = helpers.source
 | 
			
		||||
 | 
			
		||||
@@ -28,7 +28,7 @@ describe('autocmd BufEnter', function()
 | 
			
		||||
        endtry
 | 
			
		||||
      endfunction
 | 
			
		||||
    ]])
 | 
			
		||||
    execute("call Test()")
 | 
			
		||||
    command("call Test()")
 | 
			
		||||
    eq(1, eval("exists('g:dir_bufenter')"))  -- Did BufEnter for the directory.
 | 
			
		||||
    eq(2, eval("bufnr('%')"))                -- Switched to the dir buffer.
 | 
			
		||||
  end)
 | 
			
		||||
 
 | 
			
		||||
@@ -1,6 +1,6 @@
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear, eval, eq = helpers.clear, helpers.eval, helpers.eq
 | 
			
		||||
local feed, execute, expect, command = helpers.feed, helpers.execute, helpers.expect, helpers.command
 | 
			
		||||
local feed, command, expect, command = helpers.feed, helpers.command, helpers.expect, helpers.command
 | 
			
		||||
local curbufmeths, funcs, neq = helpers.curbufmeths, helpers.funcs, helpers.neq
 | 
			
		||||
 | 
			
		||||
describe('TextYankPost', function()
 | 
			
		||||
@@ -8,11 +8,11 @@ describe('TextYankPost', function()
 | 
			
		||||
    clear()
 | 
			
		||||
 | 
			
		||||
    -- emulate the clipboard so system clipboard isn't affected
 | 
			
		||||
    execute('let &rtp = "test/functional/fixtures,".&rtp')
 | 
			
		||||
    command('let &rtp = "test/functional/fixtures,".&rtp')
 | 
			
		||||
 | 
			
		||||
    execute('let g:count = 0')
 | 
			
		||||
    execute('autocmd TextYankPost * let g:event = copy(v:event)')
 | 
			
		||||
    execute('autocmd TextYankPost * let g:count += 1')
 | 
			
		||||
    command('let g:count = 0')
 | 
			
		||||
    command('autocmd TextYankPost * let g:event = copy(v:event)')
 | 
			
		||||
    command('autocmd TextYankPost * let g:count += 1')
 | 
			
		||||
 | 
			
		||||
    curbufmeths.set_lines(0, -1, true, {
 | 
			
		||||
      'foo\0bar',
 | 
			
		||||
@@ -61,27 +61,27 @@ describe('TextYankPost', function()
 | 
			
		||||
      regtype = 'V'
 | 
			
		||||
    }, eval('g:event'))
 | 
			
		||||
 | 
			
		||||
    execute('set debug=msg')
 | 
			
		||||
    command('set debug=msg')
 | 
			
		||||
    -- the regcontents should not be changed without copy.
 | 
			
		||||
    local status, err = pcall(command,'call extend(g:event.regcontents, ["more text"])')
 | 
			
		||||
    eq(status,false)
 | 
			
		||||
    neq(nil, string.find(err, ':E742:'))
 | 
			
		||||
 | 
			
		||||
    -- can't mutate keys inside the autocommand
 | 
			
		||||
    execute('autocmd! TextYankPost * let v:event.regcontents = 0')
 | 
			
		||||
    command('autocmd! TextYankPost * let v:event.regcontents = 0')
 | 
			
		||||
    status, err = pcall(command,'normal yy')
 | 
			
		||||
    eq(status,false)
 | 
			
		||||
    neq(nil, string.find(err, ':E46:'))
 | 
			
		||||
 | 
			
		||||
    -- can't add keys inside the autocommand
 | 
			
		||||
    execute('autocmd! TextYankPost * let v:event.mykey = 0')
 | 
			
		||||
    command('autocmd! TextYankPost * let v:event.mykey = 0')
 | 
			
		||||
    status, err = pcall(command,'normal yy')
 | 
			
		||||
    eq(status,false)
 | 
			
		||||
    neq(nil, string.find(err, ':E742:'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('is not invoked recursively', function()
 | 
			
		||||
    execute('autocmd TextYankPost * normal "+yy')
 | 
			
		||||
    command('autocmd TextYankPost * normal "+yy')
 | 
			
		||||
    feed('yy')
 | 
			
		||||
    eq({
 | 
			
		||||
      operator = 'y',
 | 
			
		||||
@@ -134,7 +134,7 @@ describe('TextYankPost', function()
 | 
			
		||||
    feed('"_yy')
 | 
			
		||||
    eq(0, eval('g:count'))
 | 
			
		||||
 | 
			
		||||
    execute('delete _')
 | 
			
		||||
    command('delete _')
 | 
			
		||||
    eq(0, eval('g:count'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
@@ -155,7 +155,7 @@ describe('TextYankPost', function()
 | 
			
		||||
      regtype = 'V'
 | 
			
		||||
    }, eval('g:event'))
 | 
			
		||||
 | 
			
		||||
    execute("set clipboard=unnamed")
 | 
			
		||||
    command("set clipboard=unnamed")
 | 
			
		||||
 | 
			
		||||
    -- regname still shows the name the user requested
 | 
			
		||||
    feed('yy')
 | 
			
		||||
@@ -176,7 +176,7 @@ describe('TextYankPost', function()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('works with Ex commands', function()
 | 
			
		||||
    execute('1delete +')
 | 
			
		||||
    command('1delete +')
 | 
			
		||||
    eq({
 | 
			
		||||
      operator = 'd',
 | 
			
		||||
      regcontents = { 'foo\nbar' },
 | 
			
		||||
@@ -185,7 +185,7 @@ describe('TextYankPost', function()
 | 
			
		||||
    }, eval('g:event'))
 | 
			
		||||
    eq(1, eval('g:count'))
 | 
			
		||||
 | 
			
		||||
    execute('yank')
 | 
			
		||||
    command('yank')
 | 
			
		||||
    eq({
 | 
			
		||||
      operator = 'y',
 | 
			
		||||
      regcontents = { 'baz text' },
 | 
			
		||||
@@ -194,7 +194,7 @@ describe('TextYankPost', function()
 | 
			
		||||
    }, eval('g:event'))
 | 
			
		||||
    eq(2, eval('g:count'))
 | 
			
		||||
 | 
			
		||||
    execute('normal yw')
 | 
			
		||||
    command('normal yw')
 | 
			
		||||
    eq({
 | 
			
		||||
      operator = 'y',
 | 
			
		||||
      regcontents = { 'baz ' },
 | 
			
		||||
@@ -203,7 +203,7 @@ describe('TextYankPost', function()
 | 
			
		||||
    }, eval('g:event'))
 | 
			
		||||
    eq(3, eval('g:count'))
 | 
			
		||||
 | 
			
		||||
    execute('normal! dd')
 | 
			
		||||
    command('normal! dd')
 | 
			
		||||
    eq({
 | 
			
		||||
      operator = 'd',
 | 
			
		||||
      regcontents = { 'baz text' },
 | 
			
		||||
 
 | 
			
		||||
@@ -3,7 +3,7 @@
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local Screen = require('test.functional.ui.screen')
 | 
			
		||||
local clear, feed, insert = helpers.clear, helpers.feed, helpers.insert
 | 
			
		||||
local execute, expect, eq, eval = helpers.execute, helpers.expect, helpers.eq, helpers.eval
 | 
			
		||||
local feed_command, expect, eq, eval = helpers.feed_command, helpers.expect, helpers.eq, helpers.eval
 | 
			
		||||
 | 
			
		||||
local function basic_register_test(noblock)
 | 
			
		||||
  insert("some words")
 | 
			
		||||
@@ -95,7 +95,7 @@ describe('clipboard usage', function()
 | 
			
		||||
 | 
			
		||||
  before_each(function()
 | 
			
		||||
    reset()
 | 
			
		||||
    execute('call getreg("*")') -- force load of provider
 | 
			
		||||
    feed_command('call getreg("*")') -- force load of provider
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
   it('has independent "* and unnamed registers per default', function()
 | 
			
		||||
@@ -140,8 +140,8 @@ describe('clipboard usage', function()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('support autodectection of regtype', function()
 | 
			
		||||
    execute("let g:test_clip['*'] = ['linewise stuff','']")
 | 
			
		||||
    execute("let g:test_clip['+'] = ['charwise','stuff']")
 | 
			
		||||
    feed_command("let g:test_clip['*'] = ['linewise stuff','']")
 | 
			
		||||
    feed_command("let g:test_clip['+'] = ['charwise','stuff']")
 | 
			
		||||
    eq("V", eval("getregtype('*')"))
 | 
			
		||||
    eq("v", eval("getregtype('+')"))
 | 
			
		||||
    insert("just some text")
 | 
			
		||||
@@ -156,7 +156,7 @@ describe('clipboard usage', function()
 | 
			
		||||
    insert([[
 | 
			
		||||
      much
 | 
			
		||||
      text]])
 | 
			
		||||
    execute("let g:test_clip['*'] = [['very','block'],'b']")
 | 
			
		||||
    feed_command("let g:test_clip['*'] = [['very','block'],'b']")
 | 
			
		||||
    feed('gg"*P')
 | 
			
		||||
    expect([[
 | 
			
		||||
      very much
 | 
			
		||||
@@ -170,15 +170,15 @@ describe('clipboard usage', function()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('supports setreg', function()
 | 
			
		||||
    execute('call setreg("*", "setted\\ntext", "c")')
 | 
			
		||||
    execute('call setreg("+", "explicitly\\nlines", "l")')
 | 
			
		||||
    feed_command('call setreg("*", "setted\\ntext", "c")')
 | 
			
		||||
    feed_command('call setreg("+", "explicitly\\nlines", "l")')
 | 
			
		||||
    feed('"+P"*p')
 | 
			
		||||
    expect([[
 | 
			
		||||
        esetted
 | 
			
		||||
        textxplicitly
 | 
			
		||||
        lines
 | 
			
		||||
        ]])
 | 
			
		||||
    execute('call setreg("+", "blocky\\nindeed", "b")')
 | 
			
		||||
    feed_command('call setreg("+", "blocky\\nindeed", "b")')
 | 
			
		||||
    feed('"+p')
 | 
			
		||||
    expect([[
 | 
			
		||||
        esblockyetted
 | 
			
		||||
@@ -188,13 +188,13 @@ describe('clipboard usage', function()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('supports let @+ (issue #1427)', function()
 | 
			
		||||
    execute("let @+ = 'some'")
 | 
			
		||||
    execute("let @* = ' other stuff'")
 | 
			
		||||
    feed_command("let @+ = 'some'")
 | 
			
		||||
    feed_command("let @* = ' other stuff'")
 | 
			
		||||
    eq({{'some'}, 'v'}, eval("g:test_clip['+']"))
 | 
			
		||||
    eq({{' other stuff'}, 'v'}, eval("g:test_clip['*']"))
 | 
			
		||||
    feed('"+p"*p')
 | 
			
		||||
    expect('some other stuff')
 | 
			
		||||
    execute("let @+ .= ' more'")
 | 
			
		||||
    feed_command("let @+ .= ' more'")
 | 
			
		||||
    feed('dd"+p')
 | 
			
		||||
    expect('some more')
 | 
			
		||||
  end)
 | 
			
		||||
@@ -202,7 +202,7 @@ describe('clipboard usage', function()
 | 
			
		||||
  it('pastes unnamed register if the provider fails', function()
 | 
			
		||||
    insert('the text')
 | 
			
		||||
    feed('yy')
 | 
			
		||||
    execute("let g:cliperror = 1")
 | 
			
		||||
    feed_command("let g:cliperror = 1")
 | 
			
		||||
    feed('"*p')
 | 
			
		||||
    expect([[
 | 
			
		||||
      the text
 | 
			
		||||
@@ -214,7 +214,7 @@ describe('clipboard usage', function()
 | 
			
		||||
    -- the basic behavior of unnamed register should be the same
 | 
			
		||||
    -- even when handled by clipboard provider
 | 
			
		||||
    before_each(function()
 | 
			
		||||
      execute('set clipboard=unnamed')
 | 
			
		||||
      feed_command('set clipboard=unnamed')
 | 
			
		||||
    end)
 | 
			
		||||
 | 
			
		||||
    it('works', function()
 | 
			
		||||
@@ -222,7 +222,7 @@ describe('clipboard usage', function()
 | 
			
		||||
    end)
 | 
			
		||||
 | 
			
		||||
    it('works with pure text clipboard', function()
 | 
			
		||||
      execute("let g:cliplossy = 1")
 | 
			
		||||
      feed_command("let g:cliplossy = 1")
 | 
			
		||||
      -- expect failure for block mode
 | 
			
		||||
      basic_register_test(true)
 | 
			
		||||
    end)
 | 
			
		||||
@@ -237,7 +237,7 @@ describe('clipboard usage', function()
 | 
			
		||||
      -- "+ shouldn't have changed
 | 
			
		||||
      eq({''}, eval("g:test_clip['+']"))
 | 
			
		||||
 | 
			
		||||
      execute("let g:test_clip['*'] = ['linewise stuff','']")
 | 
			
		||||
      feed_command("let g:test_clip['*'] = ['linewise stuff','']")
 | 
			
		||||
      feed('p')
 | 
			
		||||
      expect([[
 | 
			
		||||
        words
 | 
			
		||||
@@ -247,7 +247,7 @@ describe('clipboard usage', function()
 | 
			
		||||
    it('does not clobber "0 when pasting', function()
 | 
			
		||||
      insert('a line')
 | 
			
		||||
      feed('yy')
 | 
			
		||||
      execute("let g:test_clip['*'] = ['b line','']")
 | 
			
		||||
      feed_command("let g:test_clip['*'] = ['b line','']")
 | 
			
		||||
      feed('"0pp"0p')
 | 
			
		||||
      expect([[
 | 
			
		||||
        a line
 | 
			
		||||
@@ -258,20 +258,20 @@ describe('clipboard usage', function()
 | 
			
		||||
 | 
			
		||||
    it('supports v:register and getreg() without parameters', function()
 | 
			
		||||
      eq('*', eval('v:register'))
 | 
			
		||||
      execute("let g:test_clip['*'] = [['some block',''], 'b']")
 | 
			
		||||
      feed_command("let g:test_clip['*'] = [['some block',''], 'b']")
 | 
			
		||||
      eq('some block', eval('getreg()'))
 | 
			
		||||
      eq('\02210', eval('getregtype()'))
 | 
			
		||||
    end)
 | 
			
		||||
 | 
			
		||||
    it('yanks visual selection when pasting', function()
 | 
			
		||||
      insert("indeed visual")
 | 
			
		||||
      execute("let g:test_clip['*'] = [['clipboard'], 'c']")
 | 
			
		||||
      feed_command("let g:test_clip['*'] = [['clipboard'], 'c']")
 | 
			
		||||
      feed("viwp")
 | 
			
		||||
      eq({{'visual'}, 'v'}, eval("g:test_clip['*']"))
 | 
			
		||||
      expect("indeed clipboard")
 | 
			
		||||
 | 
			
		||||
      -- explicit "* should do the same
 | 
			
		||||
      execute("let g:test_clip['*'] = [['star'], 'c']")
 | 
			
		||||
      feed_command("let g:test_clip['*'] = [['star'], 'c']")
 | 
			
		||||
      feed('viw"*p')
 | 
			
		||||
      eq({{'clipboard'}, 'v'}, eval("g:test_clip['*']"))
 | 
			
		||||
      expect("indeed star")
 | 
			
		||||
@@ -280,7 +280,7 @@ describe('clipboard usage', function()
 | 
			
		||||
    it('unamed operations work even if the provider fails', function()
 | 
			
		||||
      insert('the text')
 | 
			
		||||
      feed('yy')
 | 
			
		||||
      execute("let g:cliperror = 1")
 | 
			
		||||
      feed_command("let g:cliperror = 1")
 | 
			
		||||
      feed('p')
 | 
			
		||||
      expect([[
 | 
			
		||||
        the text
 | 
			
		||||
@@ -294,11 +294,11 @@ describe('clipboard usage', function()
 | 
			
		||||
	match
 | 
			
		||||
	text
 | 
			
		||||
      ]])
 | 
			
		||||
      execute('g/match/d')
 | 
			
		||||
      feed_command('g/match/d')
 | 
			
		||||
      eq('match\n', eval('getreg("*")'))
 | 
			
		||||
      feed('u')
 | 
			
		||||
      eval('setreg("*", "---")')
 | 
			
		||||
      execute('g/test/')
 | 
			
		||||
      feed_command('g/test/')
 | 
			
		||||
      feed('<esc>')
 | 
			
		||||
      eq('---', eval('getreg("*")'))
 | 
			
		||||
    end)
 | 
			
		||||
@@ -307,7 +307,7 @@ describe('clipboard usage', function()
 | 
			
		||||
 | 
			
		||||
  describe('with clipboard=unnamedplus', function()
 | 
			
		||||
    before_each(function()
 | 
			
		||||
      execute('set clipboard=unnamedplus')
 | 
			
		||||
      feed_command('set clipboard=unnamedplus')
 | 
			
		||||
    end)
 | 
			
		||||
 | 
			
		||||
    it('links the "+ and unnamed registers', function()
 | 
			
		||||
@@ -320,13 +320,13 @@ describe('clipboard usage', function()
 | 
			
		||||
      -- "* shouldn't have changed
 | 
			
		||||
      eq({''}, eval("g:test_clip['*']"))
 | 
			
		||||
 | 
			
		||||
      execute("let g:test_clip['+'] = ['three']")
 | 
			
		||||
      feed_command("let g:test_clip['+'] = ['three']")
 | 
			
		||||
      feed('p')
 | 
			
		||||
      expect('twothree')
 | 
			
		||||
    end)
 | 
			
		||||
 | 
			
		||||
    it('and unnamed, yanks to both', function()
 | 
			
		||||
      execute('set clipboard=unnamedplus,unnamed')
 | 
			
		||||
      feed_command('set clipboard=unnamedplus,unnamed')
 | 
			
		||||
      insert([[
 | 
			
		||||
        really unnamed
 | 
			
		||||
        text]])
 | 
			
		||||
@@ -340,8 +340,8 @@ describe('clipboard usage', function()
 | 
			
		||||
 | 
			
		||||
      -- unnamedplus takes predecence when pasting
 | 
			
		||||
      eq('+', eval('v:register'))
 | 
			
		||||
      execute("let g:test_clip['+'] = ['the plus','']")
 | 
			
		||||
      execute("let g:test_clip['*'] = ['the star','']")
 | 
			
		||||
      feed_command("let g:test_clip['+'] = ['the plus','']")
 | 
			
		||||
      feed_command("let g:test_clip['*'] = ['the star','']")
 | 
			
		||||
      feed("p")
 | 
			
		||||
      expect([[
 | 
			
		||||
        text
 | 
			
		||||
@@ -356,11 +356,11 @@ describe('clipboard usage', function()
 | 
			
		||||
	match
 | 
			
		||||
	text
 | 
			
		||||
      ]])
 | 
			
		||||
      execute('g/match/d')
 | 
			
		||||
      feed_command('g/match/d')
 | 
			
		||||
      eq('match\n', eval('getreg("+")'))
 | 
			
		||||
      feed('u')
 | 
			
		||||
      eval('setreg("+", "---")')
 | 
			
		||||
      execute('g/test/')
 | 
			
		||||
      feed_command('g/test/')
 | 
			
		||||
      feed('<esc>')
 | 
			
		||||
      eq('---', eval('getreg("+")'))
 | 
			
		||||
    end)
 | 
			
		||||
@@ -375,13 +375,13 @@ describe('clipboard usage', function()
 | 
			
		||||
 | 
			
		||||
  it('supports :put', function()
 | 
			
		||||
    insert("a line")
 | 
			
		||||
    execute("let g:test_clip['*'] = ['some text']")
 | 
			
		||||
    execute("let g:test_clip['+'] = ['more', 'text', '']")
 | 
			
		||||
    execute(":put *")
 | 
			
		||||
    feed_command("let g:test_clip['*'] = ['some text']")
 | 
			
		||||
    feed_command("let g:test_clip['+'] = ['more', 'text', '']")
 | 
			
		||||
    feed_command(":put *")
 | 
			
		||||
    expect([[
 | 
			
		||||
    a line
 | 
			
		||||
    some text]])
 | 
			
		||||
    execute(":put +")
 | 
			
		||||
    feed_command(":put +")
 | 
			
		||||
    expect([[
 | 
			
		||||
    a line
 | 
			
		||||
    some text
 | 
			
		||||
@@ -392,9 +392,9 @@ describe('clipboard usage', function()
 | 
			
		||||
  it('supports "+ and "* in registers', function()
 | 
			
		||||
    local screen = Screen.new(60, 10)
 | 
			
		||||
    screen:attach()
 | 
			
		||||
    execute("let g:test_clip['*'] = ['some', 'star data','']")
 | 
			
		||||
    execute("let g:test_clip['+'] = ['such', 'plus', 'stuff']")
 | 
			
		||||
    execute("registers")
 | 
			
		||||
    feed_command("let g:test_clip['*'] = ['some', 'star data','']")
 | 
			
		||||
    feed_command("let g:test_clip['+'] = ['such', 'plus', 'stuff']")
 | 
			
		||||
    feed_command("registers")
 | 
			
		||||
    screen:expect([[
 | 
			
		||||
      ~                                                           |
 | 
			
		||||
      ~                                                           |
 | 
			
		||||
@@ -418,17 +418,17 @@ describe('clipboard usage', function()
 | 
			
		||||
    insert('s/s/t/')
 | 
			
		||||
    feed('gg"*y$:<c-r>*<cr>')
 | 
			
		||||
    expect('t/s/t/')
 | 
			
		||||
    execute("let g:test_clip['*'] = ['s/s/u']")
 | 
			
		||||
    feed_command("let g:test_clip['*'] = ['s/s/u']")
 | 
			
		||||
    feed(':<c-r>*<cr>')
 | 
			
		||||
    expect('t/u/t/')
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('supports :redir @*>', function()
 | 
			
		||||
    execute("let g:test_clip['*'] = ['stuff']")
 | 
			
		||||
    execute('redir @*>')
 | 
			
		||||
    feed_command("let g:test_clip['*'] = ['stuff']")
 | 
			
		||||
    feed_command('redir @*>')
 | 
			
		||||
    -- it is made empty
 | 
			
		||||
    eq({{''}, 'v'}, eval("g:test_clip['*']"))
 | 
			
		||||
    execute('let g:test = doesnotexist')
 | 
			
		||||
    feed_command('let g:test = doesnotexist')
 | 
			
		||||
    feed('<cr>')
 | 
			
		||||
    eq({{
 | 
			
		||||
      '',
 | 
			
		||||
@@ -436,7 +436,7 @@ describe('clipboard usage', function()
 | 
			
		||||
      'E121: Undefined variable: doesnotexist',
 | 
			
		||||
      'E15: Invalid expression: doesnotexist',
 | 
			
		||||
    }, 'v'}, eval("g:test_clip['*']"))
 | 
			
		||||
    execute(':echo "Howdy!"')
 | 
			
		||||
    feed_command(':echo "Howdy!"')
 | 
			
		||||
    eq({{
 | 
			
		||||
      '',
 | 
			
		||||
      '',
 | 
			
		||||
@@ -448,7 +448,7 @@ describe('clipboard usage', function()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('handles middleclick correctly', function()
 | 
			
		||||
    execute('set mouse=a')
 | 
			
		||||
    feed_command('set mouse=a')
 | 
			
		||||
 | 
			
		||||
    local screen = Screen.new(30, 5)
 | 
			
		||||
    screen:attach()
 | 
			
		||||
@@ -471,7 +471,7 @@ describe('clipboard usage', function()
 | 
			
		||||
      the a target]])
 | 
			
		||||
 | 
			
		||||
    -- on error, fall back to unnamed register
 | 
			
		||||
    execute("let g:cliperror = 1")
 | 
			
		||||
    feed_command("let g:cliperror = 1")
 | 
			
		||||
    feed('<MiddleMouse><6,1>')
 | 
			
		||||
    expect([[
 | 
			
		||||
      the source
 | 
			
		||||
 
 | 
			
		||||
@@ -1,7 +1,7 @@
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear, eq, eval, exc_exec, execute, feed, insert, neq, next_msg, nvim,
 | 
			
		||||
local clear, eq, eval, exc_exec, feed_command, feed, insert, neq, next_msg, nvim,
 | 
			
		||||
  nvim_dir, ok, source, write_file, mkdir, rmdir = helpers.clear,
 | 
			
		||||
  helpers.eq, helpers.eval, helpers.exc_exec, helpers.execute, helpers.feed,
 | 
			
		||||
  helpers.eq, helpers.eval, helpers.exc_exec, helpers.feed_command, helpers.feed,
 | 
			
		||||
  helpers.insert, helpers.neq, helpers.next_message, helpers.nvim,
 | 
			
		||||
  helpers.nvim_dir, helpers.ok, helpers.source,
 | 
			
		||||
  helpers.write_file, helpers.mkdir, helpers.rmdir
 | 
			
		||||
@@ -94,7 +94,7 @@ describe('jobs', function()
 | 
			
		||||
 | 
			
		||||
  it('returns 0 when it fails to start', function()
 | 
			
		||||
    eq("", eval("v:errmsg"))
 | 
			
		||||
    execute("let g:test_jobid = jobstart([])")
 | 
			
		||||
    feed_command("let g:test_jobid = jobstart([])")
 | 
			
		||||
    eq(0, eval("g:test_jobid"))
 | 
			
		||||
    eq("E474:", string.match(eval("v:errmsg"), "E%d*:"))
 | 
			
		||||
  end)
 | 
			
		||||
@@ -470,7 +470,7 @@ describe('jobs', function()
 | 
			
		||||
    end)
 | 
			
		||||
 | 
			
		||||
    it('will return -2 when interrupted', function()
 | 
			
		||||
      execute('call rpcnotify(g:channel, "ready") | '..
 | 
			
		||||
      feed_command('call rpcnotify(g:channel, "ready") | '..
 | 
			
		||||
              'call rpcnotify(g:channel, "wait", '..
 | 
			
		||||
              'jobwait([jobstart("sleep 10; exit 55")]))')
 | 
			
		||||
      eq({'notification', 'ready', {}}, next_msg())
 | 
			
		||||
@@ -514,7 +514,7 @@ describe('jobs', function()
 | 
			
		||||
        \ ])
 | 
			
		||||
      endfunction
 | 
			
		||||
      ]])
 | 
			
		||||
      execute('call Run()')
 | 
			
		||||
      feed_command('call Run()')
 | 
			
		||||
      local r
 | 
			
		||||
      for i = 10, 1, -1 do
 | 
			
		||||
        r = next_msg()
 | 
			
		||||
@@ -668,7 +668,7 @@ describe("pty process teardown", function()
 | 
			
		||||
  it("does not prevent/delay exit. #4798 #4900", function()
 | 
			
		||||
    if helpers.pending_win32(pending) then return end
 | 
			
		||||
    -- Use a nested nvim (in :term) to test without --headless.
 | 
			
		||||
    execute(":terminal '"..helpers.nvim_prog
 | 
			
		||||
    feed_command(":terminal '"..helpers.nvim_prog
 | 
			
		||||
      -- Use :term again in the _nested_ nvim to get a PTY process.
 | 
			
		||||
      -- Use `sleep` to simulate a long-running child of the PTY.
 | 
			
		||||
      .."' +terminal +'!(sleep 300 &)' +qa")
 | 
			
		||||
 
 | 
			
		||||
@@ -1,7 +1,7 @@
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local Screen = require('test.functional.ui.screen')
 | 
			
		||||
local lfs = require('lfs')
 | 
			
		||||
local neq, eq, execute = helpers.neq, helpers.eq, helpers.execute
 | 
			
		||||
local neq, eq, command = helpers.neq, helpers.eq, helpers.command
 | 
			
		||||
local clear, curbufmeths = helpers.clear, helpers.curbufmeths
 | 
			
		||||
local exc_exec, expect, eval = helpers.exc_exec, helpers.expect, helpers.eval
 | 
			
		||||
local insert = helpers.insert
 | 
			
		||||
@@ -10,17 +10,17 @@ describe('api functions', function()
 | 
			
		||||
  before_each(clear)
 | 
			
		||||
 | 
			
		||||
  it("work", function()
 | 
			
		||||
    execute("call nvim_command('let g:test = 1')")
 | 
			
		||||
    command("call nvim_command('let g:test = 1')")
 | 
			
		||||
    eq(1, eval("nvim_get_var('test')"))
 | 
			
		||||
 | 
			
		||||
    local buf = eval("nvim_get_current_buf()")
 | 
			
		||||
    execute("call nvim_buf_set_lines("..buf..", 0, -1, v:true, ['aa', 'bb'])")
 | 
			
		||||
    command("call nvim_buf_set_lines("..buf..", 0, -1, v:true, ['aa', 'bb'])")
 | 
			
		||||
    expect([[
 | 
			
		||||
      aa
 | 
			
		||||
      bb]])
 | 
			
		||||
 | 
			
		||||
    execute("call nvim_win_set_cursor(0, [1, 1])")
 | 
			
		||||
    execute("call nvim_input('ax<esc>')")
 | 
			
		||||
    command("call nvim_win_set_cursor(0, [1, 1])")
 | 
			
		||||
    command("call nvim_input('ax<esc>')")
 | 
			
		||||
    expect([[
 | 
			
		||||
      aax
 | 
			
		||||
      bb]])
 | 
			
		||||
@@ -57,7 +57,7 @@ describe('api functions', function()
 | 
			
		||||
    eq(bnr, bhnd)
 | 
			
		||||
    eq(wid, whnd)
 | 
			
		||||
 | 
			
		||||
    execute("new") -- creates new buffer and new window
 | 
			
		||||
    command("new") -- creates new buffer and new window
 | 
			
		||||
    local bnr2 = eval("bufnr('')")
 | 
			
		||||
    local bhnd2 = eval("nvim_get_current_buf()")
 | 
			
		||||
    local wid2 = eval("win_getid()")
 | 
			
		||||
@@ -69,7 +69,7 @@ describe('api functions', function()
 | 
			
		||||
    -- 0 is synonymous to the current buffer
 | 
			
		||||
    eq(bnr2, eval("nvim_buf_get_number(0)"))
 | 
			
		||||
 | 
			
		||||
    execute("bn") -- show old buffer in new window
 | 
			
		||||
    command("bn") -- show old buffer in new window
 | 
			
		||||
    eq(bnr, eval("nvim_get_current_buf()"))
 | 
			
		||||
    eq(bnr, eval("bufnr('')"))
 | 
			
		||||
    eq(bnr, eval("nvim_buf_get_number(0)"))
 | 
			
		||||
@@ -81,7 +81,7 @@ describe('api functions', function()
 | 
			
		||||
    curbufmeths.set_lines(0, -1, true, {"aa\0", "b\0b"})
 | 
			
		||||
    eq({'aa\n', 'b\nb'}, eval("nvim_buf_get_lines(0, 0, -1, 1)"))
 | 
			
		||||
 | 
			
		||||
    execute('call nvim_buf_set_lines(0, 1, 2, v:true, ["xx", "\\nyy"])')
 | 
			
		||||
    command('call nvim_buf_set_lines(0, 1, 2, v:true, ["xx", "\\nyy"])')
 | 
			
		||||
    eq({'aa\0', 'xx', '\0yy'}, curbufmeths.get_lines(0, -1, 1))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
@@ -124,9 +124,9 @@ describe('api functions', function()
 | 
			
		||||
      [5] = {bold = true, foreground = Screen.colors.Blue},
 | 
			
		||||
    })
 | 
			
		||||
 | 
			
		||||
    execute("set ft=vim")
 | 
			
		||||
    execute("let &rtp='build/runtime/,'.&rtp")
 | 
			
		||||
    execute("syntax on")
 | 
			
		||||
    command("set ft=vim")
 | 
			
		||||
    command("let &rtp='build/runtime/,'.&rtp")
 | 
			
		||||
    command("syntax on")
 | 
			
		||||
    insert([[
 | 
			
		||||
      call bufnr('%')
 | 
			
		||||
      call nvim_input('typing...')
 | 
			
		||||
 
 | 
			
		||||
@@ -1,13 +1,13 @@
 | 
			
		||||
local lfs = require('lfs')
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear, execute, eval, eq = helpers.clear, helpers.execute, helpers.eval, helpers.eq
 | 
			
		||||
local clear, command, eval, eq = helpers.clear, helpers.command, helpers.eval, helpers.eq
 | 
			
		||||
 | 
			
		||||
before_each(function()
 | 
			
		||||
  clear()
 | 
			
		||||
  lfs.mkdir('test-glob')
 | 
			
		||||
 | 
			
		||||
  -- Long path might cause "Press ENTER" prompt; use :silent to avoid it.
 | 
			
		||||
  execute('silent cd test-glob')
 | 
			
		||||
  command('silent cd test-glob')
 | 
			
		||||
end)
 | 
			
		||||
 | 
			
		||||
after_each(function()
 | 
			
		||||
 
 | 
			
		||||
@@ -4,16 +4,17 @@ local funcs = helpers.funcs
 | 
			
		||||
local meths = helpers.meths
 | 
			
		||||
local eq = helpers.eq
 | 
			
		||||
local eval = helpers.eval
 | 
			
		||||
local execute = helpers.execute
 | 
			
		||||
local command = helpers.command
 | 
			
		||||
local exc_exec = helpers.exc_exec
 | 
			
		||||
local redir_exec = helpers.redir_exec
 | 
			
		||||
local NIL = helpers.NIL
 | 
			
		||||
local source = helpers.source
 | 
			
		||||
 | 
			
		||||
describe('json_decode() function', function()
 | 
			
		||||
  local restart = function(...)
 | 
			
		||||
    clear(...)
 | 
			
		||||
    execute('language C')
 | 
			
		||||
    execute([[
 | 
			
		||||
    source([[
 | 
			
		||||
      language C
 | 
			
		||||
      function Eq(exp, act)
 | 
			
		||||
        let act = a:act
 | 
			
		||||
        let exp = a:exp
 | 
			
		||||
@@ -45,8 +46,6 @@ describe('json_decode() function', function()
 | 
			
		||||
        endif
 | 
			
		||||
        return 1
 | 
			
		||||
      endfunction
 | 
			
		||||
    ]])
 | 
			
		||||
    execute([[
 | 
			
		||||
      function EvalEq(exp, act_expr)
 | 
			
		||||
        let act = eval(a:act_expr)
 | 
			
		||||
        if Eq(a:exp, act)
 | 
			
		||||
@@ -441,7 +440,7 @@ describe('json_decode() function', function()
 | 
			
		||||
  local sp_decode_eq = function(expected, json)
 | 
			
		||||
    meths.set_var('__json', json)
 | 
			
		||||
    speq(expected, 'json_decode(g:__json)')
 | 
			
		||||
    execute('unlet! g:__json')
 | 
			
		||||
    command('unlet! g:__json')
 | 
			
		||||
  end
 | 
			
		||||
 | 
			
		||||
  it('parses strings with NUL properly', function()
 | 
			
		||||
@@ -527,7 +526,7 @@ end)
 | 
			
		||||
describe('json_encode() function', function()
 | 
			
		||||
  before_each(function()
 | 
			
		||||
    clear()
 | 
			
		||||
    execute('language C')
 | 
			
		||||
    command('language C')
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('dumps strings', function()
 | 
			
		||||
@@ -576,94 +575,94 @@ describe('json_encode() function', function()
 | 
			
		||||
 | 
			
		||||
  it('cannot dump generic mapping with generic mapping keys and values',
 | 
			
		||||
  function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.map, "_VAL": []}')
 | 
			
		||||
    execute('let todumpv1 = {"_TYPE": v:msgpack_types.map, "_VAL": []}')
 | 
			
		||||
    execute('let todumpv2 = {"_TYPE": v:msgpack_types.map, "_VAL": []}')
 | 
			
		||||
    execute('call add(todump._VAL, [todumpv1, todumpv2])')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.map, "_VAL": []}')
 | 
			
		||||
    command('let todumpv1 = {"_TYPE": v:msgpack_types.map, "_VAL": []}')
 | 
			
		||||
    command('let todumpv2 = {"_TYPE": v:msgpack_types.map, "_VAL": []}')
 | 
			
		||||
    command('call add(todump._VAL, [todumpv1, todumpv2])')
 | 
			
		||||
    eq('Vim(call):E474: Invalid key in special dictionary', exc_exec('call json_encode(todump)'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('cannot dump generic mapping with ext key', function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.ext, "_VAL": [5, ["",""]]}')
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.map, "_VAL": [[todump, 1]]}')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.ext, "_VAL": [5, ["",""]]}')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.map, "_VAL": [[todump, 1]]}')
 | 
			
		||||
    eq('Vim(call):E474: Invalid key in special dictionary', exc_exec('call json_encode(todump)'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('cannot dump generic mapping with array key', function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.array, "_VAL": [5, [""]]}')
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.map, "_VAL": [[todump, 1]]}')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.array, "_VAL": [5, [""]]}')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.map, "_VAL": [[todump, 1]]}')
 | 
			
		||||
    eq('Vim(call):E474: Invalid key in special dictionary', exc_exec('call json_encode(todump)'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('cannot dump generic mapping with UINT64_MAX key', function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.integer}')
 | 
			
		||||
    execute('let todump._VAL = [1, 3, 0x7FFFFFFF, 0x7FFFFFFF]')
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.map, "_VAL": [[todump, 1]]}')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.integer}')
 | 
			
		||||
    command('let todump._VAL = [1, 3, 0x7FFFFFFF, 0x7FFFFFFF]')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.map, "_VAL": [[todump, 1]]}')
 | 
			
		||||
    eq('Vim(call):E474: Invalid key in special dictionary', exc_exec('call json_encode(todump)'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('cannot dump generic mapping with floating-point key', function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.float, "_VAL": 0.125}')
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.map, "_VAL": [[todump, 1]]}')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.float, "_VAL": 0.125}')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.map, "_VAL": [[todump, 1]]}')
 | 
			
		||||
    eq('Vim(call):E474: Invalid key in special dictionary', exc_exec('call json_encode(todump)'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('can dump generic mapping with STR special key and NUL', function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.string, "_VAL": ["\\n"]}')
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.map, "_VAL": [[todump, 1]]}')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.string, "_VAL": ["\\n"]}')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.map, "_VAL": [[todump, 1]]}')
 | 
			
		||||
    eq('{"\\u0000": 1}', eval('json_encode(todump)'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('can dump generic mapping with BIN special key and NUL', function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.binary, "_VAL": ["\\n"]}')
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.map, "_VAL": [[todump, 1]]}')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.binary, "_VAL": ["\\n"]}')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.map, "_VAL": [[todump, 1]]}')
 | 
			
		||||
    eq('{"\\u0000": 1}', eval('json_encode(todump)'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('can dump STR special mapping with NUL and NL', function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.string, "_VAL": ["\\n", ""]}')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.string, "_VAL": ["\\n", ""]}')
 | 
			
		||||
    eq('"\\u0000\\n"', eval('json_encode(todump)'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('can dump BIN special mapping with NUL and NL', function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.binary, "_VAL": ["\\n", ""]}')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.binary, "_VAL": ["\\n", ""]}')
 | 
			
		||||
    eq('"\\u0000\\n"', eval('json_encode(todump)'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('cannot dump special ext mapping', function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.ext, "_VAL": [5, ["",""]]}')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.ext, "_VAL": [5, ["",""]]}')
 | 
			
		||||
    eq('Vim(call):E474: Unable to convert EXT string to JSON', exc_exec('call json_encode(todump)'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('can dump special array mapping', function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.array, "_VAL": [5, [""]]}')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.array, "_VAL": [5, [""]]}')
 | 
			
		||||
    eq('[5, [""]]', eval('json_encode(todump)'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('can dump special UINT64_MAX mapping', function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.integer}')
 | 
			
		||||
    execute('let todump._VAL = [1, 3, 0x7FFFFFFF, 0x7FFFFFFF]')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.integer}')
 | 
			
		||||
    command('let todump._VAL = [1, 3, 0x7FFFFFFF, 0x7FFFFFFF]')
 | 
			
		||||
    eq('18446744073709551615', eval('json_encode(todump)'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('can dump special INT64_MIN mapping', function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.integer}')
 | 
			
		||||
    execute('let todump._VAL = [-1, 2, 0, 0]')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.integer}')
 | 
			
		||||
    command('let todump._VAL = [-1, 2, 0, 0]')
 | 
			
		||||
    eq('-9223372036854775808', eval('json_encode(todump)'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('can dump special BOOLEAN true mapping', function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.boolean, "_VAL": 1}')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.boolean, "_VAL": 1}')
 | 
			
		||||
    eq('true', eval('json_encode(todump)'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('can dump special BOOLEAN false mapping', function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.boolean, "_VAL": 0}')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.boolean, "_VAL": 0}')
 | 
			
		||||
    eq('false', eval('json_encode(todump)'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('can dump special NIL mapping', function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.nil, "_VAL": 0}')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.nil, "_VAL": 0}')
 | 
			
		||||
    eq('null', eval('json_encode(todump)'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
@@ -673,7 +672,7 @@ describe('json_encode() function', function()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('fails to dump a partial', function()
 | 
			
		||||
    execute('function T() dict\nendfunction')
 | 
			
		||||
    command('function T() dict\nendfunction')
 | 
			
		||||
    eq('Vim(call):E474: Error while dumping encode_tv2json() argument, itself: attempt to dump function reference',
 | 
			
		||||
       exc_exec('call json_encode(function("T", [1, 2], {}))'))
 | 
			
		||||
  end)
 | 
			
		||||
@@ -684,56 +683,56 @@ describe('json_encode() function', function()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('fails to dump a recursive list', function()
 | 
			
		||||
    execute('let todump = [[[]]]')
 | 
			
		||||
    execute('call add(todump[0][0], todump)')
 | 
			
		||||
    command('let todump = [[[]]]')
 | 
			
		||||
    command('call add(todump[0][0], todump)')
 | 
			
		||||
    eq('Vim(call):E724: unable to correctly dump variable with self-referencing container',
 | 
			
		||||
       exc_exec('call json_encode(todump)'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('fails to dump a recursive dict', function()
 | 
			
		||||
    execute('let todump = {"d": {"d": {}}}')
 | 
			
		||||
    execute('call extend(todump.d.d, {"d": todump})')
 | 
			
		||||
    command('let todump = {"d": {"d": {}}}')
 | 
			
		||||
    command('call extend(todump.d.d, {"d": todump})')
 | 
			
		||||
    eq('Vim(call):E724: unable to correctly dump variable with self-referencing container',
 | 
			
		||||
       exc_exec('call json_encode([todump])'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('can dump dict with two same dicts inside', function()
 | 
			
		||||
    execute('let inter = {}')
 | 
			
		||||
    execute('let todump = {"a": inter, "b": inter}')
 | 
			
		||||
    command('let inter = {}')
 | 
			
		||||
    command('let todump = {"a": inter, "b": inter}')
 | 
			
		||||
    eq('{"a": {}, "b": {}}', eval('json_encode(todump)'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('can dump list with two same lists inside', function()
 | 
			
		||||
    execute('let inter = []')
 | 
			
		||||
    execute('let todump = [inter, inter]')
 | 
			
		||||
    command('let inter = []')
 | 
			
		||||
    command('let todump = [inter, inter]')
 | 
			
		||||
    eq('[[], []]', eval('json_encode(todump)'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('fails to dump a recursive list in a special dict', function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.array, "_VAL": []}')
 | 
			
		||||
    execute('call add(todump._VAL, todump)')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.array, "_VAL": []}')
 | 
			
		||||
    command('call add(todump._VAL, todump)')
 | 
			
		||||
    eq('Vim(call):E724: unable to correctly dump variable with self-referencing container',
 | 
			
		||||
       exc_exec('call json_encode(todump)'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('fails to dump a recursive (val) map in a special dict', function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.map, "_VAL": []}')
 | 
			
		||||
    execute('call add(todump._VAL, ["", todump])')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.map, "_VAL": []}')
 | 
			
		||||
    command('call add(todump._VAL, ["", todump])')
 | 
			
		||||
    eq('Vim(call):E724: unable to correctly dump variable with self-referencing container',
 | 
			
		||||
       exc_exec('call json_encode([todump])'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('fails to dump a recursive (val) map in a special dict, _VAL reference', function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.map, "_VAL": [["", []]]}')
 | 
			
		||||
    execute('call add(todump._VAL[0][1], todump._VAL)')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.map, "_VAL": [["", []]]}')
 | 
			
		||||
    command('call add(todump._VAL[0][1], todump._VAL)')
 | 
			
		||||
    eq('Vim(call):E724: unable to correctly dump variable with self-referencing container',
 | 
			
		||||
       exc_exec('call json_encode(todump)'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('fails to dump a recursive (val) special list in a special dict',
 | 
			
		||||
  function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.array, "_VAL": []}')
 | 
			
		||||
    execute('call add(todump._VAL, ["", todump._VAL])')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.array, "_VAL": []}')
 | 
			
		||||
    command('call add(todump._VAL, ["", todump._VAL])')
 | 
			
		||||
    eq('Vim(call):E724: unable to correctly dump variable with self-referencing container',
 | 
			
		||||
       exc_exec('call json_encode(todump)'))
 | 
			
		||||
  end)
 | 
			
		||||
 
 | 
			
		||||
@@ -1,5 +1,5 @@
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear, execute, write_file = helpers.clear, helpers.execute, helpers.write_file
 | 
			
		||||
local clear, command, write_file = helpers.clear, helpers.command, helpers.write_file
 | 
			
		||||
local eq, eval = helpers.eq, helpers.eval
 | 
			
		||||
 | 
			
		||||
describe("modeline", function()
 | 
			
		||||
@@ -12,7 +12,7 @@ describe("modeline", function()
 | 
			
		||||
 | 
			
		||||
  it('does not crash with a large version number', function()
 | 
			
		||||
    write_file(tempfile, 'vim100000000000000000000000')
 | 
			
		||||
    execute('e! ' .. tempfile)
 | 
			
		||||
    command('e! ' .. tempfile)
 | 
			
		||||
 | 
			
		||||
    eq(2, eval('1+1'))  -- Still alive?
 | 
			
		||||
  end)
 | 
			
		||||
 
 | 
			
		||||
@@ -2,7 +2,7 @@ local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear = helpers.clear
 | 
			
		||||
local funcs = helpers.funcs
 | 
			
		||||
local eval, eq = helpers.eval, helpers.eq
 | 
			
		||||
local execute = helpers.execute
 | 
			
		||||
local command = helpers.command
 | 
			
		||||
local nvim = helpers.nvim
 | 
			
		||||
local exc_exec = helpers.exc_exec
 | 
			
		||||
 | 
			
		||||
@@ -331,9 +331,9 @@ describe('msgpack*() functions', function()
 | 
			
		||||
  obj_test('are able to dump and restore floating-point value', {0.125})
 | 
			
		||||
 | 
			
		||||
  it('can restore and dump UINT64_MAX', function()
 | 
			
		||||
    execute('let dumped = ["\\xCF" . repeat("\\xFF", 8)]')
 | 
			
		||||
    execute('let parsed = msgpackparse(dumped)')
 | 
			
		||||
    execute('let dumped2 = msgpackdump(parsed)')
 | 
			
		||||
    command('let dumped = ["\\xCF" . repeat("\\xFF", 8)]')
 | 
			
		||||
    command('let parsed = msgpackparse(dumped)')
 | 
			
		||||
    command('let dumped2 = msgpackdump(parsed)')
 | 
			
		||||
    eq(1, eval('type(parsed[0]) == type(0) ' ..
 | 
			
		||||
               '|| parsed[0]._TYPE is v:msgpack_types.integer'))
 | 
			
		||||
    if eval('type(parsed[0]) == type(0)') == 1 then
 | 
			
		||||
@@ -345,9 +345,9 @@ describe('msgpack*() functions', function()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('can restore and dump INT64_MIN', function()
 | 
			
		||||
    execute('let dumped = ["\\xD3\\x80" . repeat("\\n", 7)]')
 | 
			
		||||
    execute('let parsed = msgpackparse(dumped)')
 | 
			
		||||
    execute('let dumped2 = msgpackdump(parsed)')
 | 
			
		||||
    command('let dumped = ["\\xD3\\x80" . repeat("\\n", 7)]')
 | 
			
		||||
    command('let parsed = msgpackparse(dumped)')
 | 
			
		||||
    command('let dumped2 = msgpackdump(parsed)')
 | 
			
		||||
    eq(1, eval('type(parsed[0]) == type(0) ' ..
 | 
			
		||||
               '|| parsed[0]._TYPE is v:msgpack_types.integer'))
 | 
			
		||||
    if eval('type(parsed[0]) == type(0)') == 1 then
 | 
			
		||||
@@ -359,33 +359,33 @@ describe('msgpack*() functions', function()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('can restore and dump BIN string with zero byte', function()
 | 
			
		||||
    execute('let dumped = ["\\xC4\\x01\\n"]')
 | 
			
		||||
    execute('let parsed = msgpackparse(dumped)')
 | 
			
		||||
    execute('let dumped2 = msgpackdump(parsed)')
 | 
			
		||||
    command('let dumped = ["\\xC4\\x01\\n"]')
 | 
			
		||||
    command('let parsed = msgpackparse(dumped)')
 | 
			
		||||
    command('let dumped2 = msgpackdump(parsed)')
 | 
			
		||||
    eq({{_TYPE={}, _VAL={'\n'}}}, eval('parsed'))
 | 
			
		||||
    eq(1, eval('parsed[0]._TYPE is v:msgpack_types.binary'))
 | 
			
		||||
    eq(1, eval('dumped ==# dumped2'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('can restore and dump STR string with zero byte', function()
 | 
			
		||||
    execute('let dumped = ["\\xA1\\n"]')
 | 
			
		||||
    execute('let parsed = msgpackparse(dumped)')
 | 
			
		||||
    execute('let dumped2 = msgpackdump(parsed)')
 | 
			
		||||
    command('let dumped = ["\\xA1\\n"]')
 | 
			
		||||
    command('let parsed = msgpackparse(dumped)')
 | 
			
		||||
    command('let dumped2 = msgpackdump(parsed)')
 | 
			
		||||
    eq({{_TYPE={}, _VAL={'\n'}}}, eval('parsed'))
 | 
			
		||||
    eq(1, eval('parsed[0]._TYPE is v:msgpack_types.string'))
 | 
			
		||||
    eq(1, eval('dumped ==# dumped2'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('can restore and dump BIN string with NL', function()
 | 
			
		||||
    execute('let dumped = ["\\xC4\\x01", ""]')
 | 
			
		||||
    execute('let parsed = msgpackparse(dumped)')
 | 
			
		||||
    execute('let dumped2 = msgpackdump(parsed)')
 | 
			
		||||
    command('let dumped = ["\\xC4\\x01", ""]')
 | 
			
		||||
    command('let parsed = msgpackparse(dumped)')
 | 
			
		||||
    command('let dumped2 = msgpackdump(parsed)')
 | 
			
		||||
    eq({"\n"}, eval('parsed'))
 | 
			
		||||
    eq(1, eval('dumped ==# dumped2'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('dump and restore special mapping with floating-point value', function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.float, "_VAL": 0.125}')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.float, "_VAL": 0.125}')
 | 
			
		||||
    eq({0.125}, eval('msgpackparse(msgpackdump([todump]))'))
 | 
			
		||||
  end)
 | 
			
		||||
end)
 | 
			
		||||
@@ -394,52 +394,53 @@ describe('msgpackparse() function', function()
 | 
			
		||||
  before_each(clear)
 | 
			
		||||
 | 
			
		||||
  it('restores nil as v:null', function()
 | 
			
		||||
    execute('let dumped = ["\\xC0"]')
 | 
			
		||||
    execute('let parsed = msgpackparse(dumped)')
 | 
			
		||||
    command('let dumped = ["\\xC0"]')
 | 
			
		||||
    command('let parsed = msgpackparse(dumped)')
 | 
			
		||||
    eq('[v:null]', eval('string(parsed)'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('restores boolean false as v:false', function()
 | 
			
		||||
    execute('let dumped = ["\\xC2"]')
 | 
			
		||||
    execute('let parsed = msgpackparse(dumped)')
 | 
			
		||||
    command('let dumped = ["\\xC2"]')
 | 
			
		||||
    command('let parsed = msgpackparse(dumped)')
 | 
			
		||||
    eq({false}, eval('parsed'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('restores boolean true as v:true', function()
 | 
			
		||||
    execute('let dumped = ["\\xC3"]')
 | 
			
		||||
    execute('let parsed = msgpackparse(dumped)')
 | 
			
		||||
    command('let dumped = ["\\xC3"]')
 | 
			
		||||
    command('let parsed = msgpackparse(dumped)')
 | 
			
		||||
    eq({true}, eval('parsed'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('restores FIXSTR as special dict', function()
 | 
			
		||||
    execute('let dumped = ["\\xa2ab"]')
 | 
			
		||||
    execute('let parsed = msgpackparse(dumped)')
 | 
			
		||||
    command('let dumped = ["\\xa2ab"]')
 | 
			
		||||
    command('let parsed = msgpackparse(dumped)')
 | 
			
		||||
    eq({{_TYPE={}, _VAL={'ab'}}}, eval('parsed'))
 | 
			
		||||
    eq(1, eval('g:parsed[0]._TYPE is v:msgpack_types.string'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('restores BIN 8 as string', function()
 | 
			
		||||
    execute('let dumped = ["\\xC4\\x02ab"]')
 | 
			
		||||
    command('let dumped = ["\\xC4\\x02ab"]')
 | 
			
		||||
    eq({'ab'}, eval('msgpackparse(dumped)'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('restores FIXEXT1 as special dictionary', function()
 | 
			
		||||
    execute('let dumped = ["\\xD4\\x10", ""]')
 | 
			
		||||
    execute('let parsed = msgpackparse(dumped)')
 | 
			
		||||
    command('let dumped = ["\\xD4\\x10", ""]')
 | 
			
		||||
    command('let parsed = msgpackparse(dumped)')
 | 
			
		||||
    eq({{_TYPE={}, _VAL={0x10, {"", ""}}}}, eval('parsed'))
 | 
			
		||||
    eq(1, eval('g:parsed[0]._TYPE is v:msgpack_types.ext'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('restores MAP with BIN key as special dictionary', function()
 | 
			
		||||
    execute('let dumped = ["\\x81\\xC4\\x01a\\xC4\\n"]')
 | 
			
		||||
    execute('let parsed = msgpackparse(dumped)')
 | 
			
		||||
    command('let dumped = ["\\x81\\xC4\\x01a\\xC4\\n"]')
 | 
			
		||||
    command('let parsed = msgpackparse(dumped)')
 | 
			
		||||
    eq({{_TYPE={}, _VAL={{'a', ''}}}}, eval('parsed'))
 | 
			
		||||
    eq(1, eval('g:parsed[0]._TYPE is v:msgpack_types.map'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('restores MAP with duplicate STR keys as special dictionary', function()
 | 
			
		||||
    execute('let dumped = ["\\x82\\xA1a\\xC4\\n\\xA1a\\xC4\\n"]')
 | 
			
		||||
    execute('let parsed = msgpackparse(dumped)')
 | 
			
		||||
    command('let dumped = ["\\x82\\xA1a\\xC4\\n\\xA1a\\xC4\\n"]')
 | 
			
		||||
    -- FIXME Internal error bug
 | 
			
		||||
    command('silent! let parsed = msgpackparse(dumped)')
 | 
			
		||||
    eq({{_TYPE={}, _VAL={ {{_TYPE={}, _VAL={'a'}}, ''},
 | 
			
		||||
                          {{_TYPE={}, _VAL={'a'}}, ''}}} }, eval('parsed'))
 | 
			
		||||
    eq(1, eval('g:parsed[0]._TYPE is v:msgpack_types.map'))
 | 
			
		||||
@@ -448,8 +449,8 @@ describe('msgpackparse() function', function()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('restores MAP with MAP key as special dictionary', function()
 | 
			
		||||
    execute('let dumped = ["\\x81\\x80\\xC4\\n"]')
 | 
			
		||||
    execute('let parsed = msgpackparse(dumped)')
 | 
			
		||||
    command('let dumped = ["\\x81\\x80\\xC4\\n"]')
 | 
			
		||||
    command('let parsed = msgpackparse(dumped)')
 | 
			
		||||
    eq({{_TYPE={}, _VAL={{{}, ''}}}}, eval('parsed'))
 | 
			
		||||
    eq(1, eval('g:parsed[0]._TYPE is v:msgpack_types.map'))
 | 
			
		||||
  end)
 | 
			
		||||
@@ -494,7 +495,7 @@ describe('msgpackparse() function', function()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('fails to parse a partial', function()
 | 
			
		||||
    execute('function T() dict\nendfunction')
 | 
			
		||||
    command('function T() dict\nendfunction')
 | 
			
		||||
    eq('Vim(call):E686: Argument of msgpackparse() must be a List',
 | 
			
		||||
       exc_exec('call msgpackparse(function("T", [1, 2], {}))'))
 | 
			
		||||
  end)
 | 
			
		||||
@@ -514,10 +515,10 @@ describe('msgpackdump() function', function()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('can dump generic mapping with generic mapping keys and values', function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.map, "_VAL": []}')
 | 
			
		||||
    execute('let todumpv1 = {"_TYPE": v:msgpack_types.map, "_VAL": []}')
 | 
			
		||||
    execute('let todumpv2 = {"_TYPE": v:msgpack_types.map, "_VAL": []}')
 | 
			
		||||
    execute('call add(todump._VAL, [todumpv1, todumpv2])')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.map, "_VAL": []}')
 | 
			
		||||
    command('let todumpv1 = {"_TYPE": v:msgpack_types.map, "_VAL": []}')
 | 
			
		||||
    command('let todumpv2 = {"_TYPE": v:msgpack_types.map, "_VAL": []}')
 | 
			
		||||
    command('call add(todump._VAL, [todumpv1, todumpv2])')
 | 
			
		||||
    eq({'\129\128\128'}, eval('msgpackdump([todump])'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
@@ -530,130 +531,130 @@ describe('msgpackdump() function', function()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('can v:null', function()
 | 
			
		||||
    execute('let todump = v:null')
 | 
			
		||||
    command('let todump = v:null')
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('can dump special bool mapping (true)', function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.boolean, "_VAL": 1}')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.boolean, "_VAL": 1}')
 | 
			
		||||
    eq({'\195'}, eval('msgpackdump([todump])'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('can dump special bool mapping (false)', function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.boolean, "_VAL": 0}')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.boolean, "_VAL": 0}')
 | 
			
		||||
    eq({'\194'}, eval('msgpackdump([todump])'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('can dump special nil mapping', function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.nil, "_VAL": 0}')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.nil, "_VAL": 0}')
 | 
			
		||||
    eq({'\192'}, eval('msgpackdump([todump])'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('can dump special ext mapping', function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.ext, "_VAL": [5, ["",""]]}')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.ext, "_VAL": [5, ["",""]]}')
 | 
			
		||||
    eq({'\212\005', ''}, eval('msgpackdump([todump])'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('can dump special array mapping', function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.array, "_VAL": [5, [""]]}')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.array, "_VAL": [5, [""]]}')
 | 
			
		||||
    eq({'\146\005\145\196\n'}, eval('msgpackdump([todump])'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('can dump special UINT64_MAX mapping', function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.integer}')
 | 
			
		||||
    execute('let todump._VAL = [1, 3, 0x7FFFFFFF, 0x7FFFFFFF]')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.integer}')
 | 
			
		||||
    command('let todump._VAL = [1, 3, 0x7FFFFFFF, 0x7FFFFFFF]')
 | 
			
		||||
    eq({'\207\255\255\255\255\255\255\255\255'}, eval('msgpackdump([todump])'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('can dump special INT64_MIN mapping', function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.integer}')
 | 
			
		||||
    execute('let todump._VAL = [-1, 2, 0, 0]')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.integer}')
 | 
			
		||||
    command('let todump._VAL = [-1, 2, 0, 0]')
 | 
			
		||||
    eq({'\211\128\n\n\n\n\n\n\n'}, eval('msgpackdump([todump])'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('fails to dump a function reference', function()
 | 
			
		||||
    execute('let Todump = function("tr")')
 | 
			
		||||
    command('let Todump = function("tr")')
 | 
			
		||||
    eq('Vim(call):E5004: Error while dumping msgpackdump() argument, index 0, itself: attempt to dump function reference',
 | 
			
		||||
       exc_exec('call msgpackdump([Todump])'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('fails to dump a partial', function()
 | 
			
		||||
    execute('function T() dict\nendfunction')
 | 
			
		||||
    execute('let Todump = function("T", [1, 2], {})')
 | 
			
		||||
    command('function T() dict\nendfunction')
 | 
			
		||||
    command('let Todump = function("T", [1, 2], {})')
 | 
			
		||||
    eq('Vim(call):E5004: Error while dumping msgpackdump() argument, index 0, itself: attempt to dump function reference',
 | 
			
		||||
       exc_exec('call msgpackdump([Todump])'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('fails to dump a function reference in a list', function()
 | 
			
		||||
    execute('let todump = [function("tr")]')
 | 
			
		||||
    command('let todump = [function("tr")]')
 | 
			
		||||
    eq('Vim(call):E5004: Error while dumping msgpackdump() argument, index 0, index 0: attempt to dump function reference',
 | 
			
		||||
       exc_exec('call msgpackdump([todump])'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('fails to dump a recursive list', function()
 | 
			
		||||
    execute('let todump = [[[]]]')
 | 
			
		||||
    execute('call add(todump[0][0], todump)')
 | 
			
		||||
    command('let todump = [[[]]]')
 | 
			
		||||
    command('call add(todump[0][0], todump)')
 | 
			
		||||
    eq('Vim(call):E5005: Unable to dump msgpackdump() argument, index 0: container references itself in index 0, index 0, index 0',
 | 
			
		||||
       exc_exec('call msgpackdump([todump])'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('fails to dump a recursive dict', function()
 | 
			
		||||
    execute('let todump = {"d": {"d": {}}}')
 | 
			
		||||
    execute('call extend(todump.d.d, {"d": todump})')
 | 
			
		||||
    command('let todump = {"d": {"d": {}}}')
 | 
			
		||||
    command('call extend(todump.d.d, {"d": todump})')
 | 
			
		||||
    eq('Vim(call):E5005: Unable to dump msgpackdump() argument, index 0: container references itself in key \'d\', key \'d\', key \'d\'',
 | 
			
		||||
       exc_exec('call msgpackdump([todump])'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('can dump dict with two same dicts inside', function()
 | 
			
		||||
    execute('let inter = {}')
 | 
			
		||||
    execute('let todump = {"a": inter, "b": inter}')
 | 
			
		||||
    command('let inter = {}')
 | 
			
		||||
    command('let todump = {"a": inter, "b": inter}')
 | 
			
		||||
    eq({"\130\161a\128\161b\128"}, eval('msgpackdump([todump])'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('can dump list with two same lists inside', function()
 | 
			
		||||
    execute('let inter = []')
 | 
			
		||||
    execute('let todump = [inter, inter]')
 | 
			
		||||
    command('let inter = []')
 | 
			
		||||
    command('let todump = [inter, inter]')
 | 
			
		||||
    eq({"\146\144\144"}, eval('msgpackdump([todump])'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('fails to dump a recursive list in a special dict', function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.array, "_VAL": []}')
 | 
			
		||||
    execute('call add(todump._VAL, todump)')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.array, "_VAL": []}')
 | 
			
		||||
    command('call add(todump._VAL, todump)')
 | 
			
		||||
    eq('Vim(call):E5005: Unable to dump msgpackdump() argument, index 0: container references itself in index 0',
 | 
			
		||||
       exc_exec('call msgpackdump([todump])'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('fails to dump a recursive (key) map in a special dict', function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.map, "_VAL": []}')
 | 
			
		||||
    execute('call add(todump._VAL, [todump, 0])')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.map, "_VAL": []}')
 | 
			
		||||
    command('call add(todump._VAL, [todump, 0])')
 | 
			
		||||
    eq('Vim(call):E5005: Unable to dump msgpackdump() argument, index 0: container references itself in index 1',
 | 
			
		||||
       exc_exec('call msgpackdump([todump])'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('fails to dump a recursive (val) map in a special dict', function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.map, "_VAL": []}')
 | 
			
		||||
    execute('call add(todump._VAL, [0, todump])')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.map, "_VAL": []}')
 | 
			
		||||
    command('call add(todump._VAL, [0, todump])')
 | 
			
		||||
    eq('Vim(call):E5005: Unable to dump msgpackdump() argument, index 0: container references itself in key 0 at index 0 from special map',
 | 
			
		||||
       exc_exec('call msgpackdump([todump])'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('fails to dump a recursive (key) map in a special dict, _VAL reference', function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.map, "_VAL": [[[], []]]}')
 | 
			
		||||
    execute('call add(todump._VAL[0][0], todump._VAL)')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.map, "_VAL": [[[], []]]}')
 | 
			
		||||
    command('call add(todump._VAL[0][0], todump._VAL)')
 | 
			
		||||
    eq('Vim(call):E5005: Unable to dump msgpackdump() argument, index 0: container references itself in key [[[[...@0], []]]] at index 0 from special map, index 0',
 | 
			
		||||
       exc_exec('call msgpackdump([todump])'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('fails to dump a recursive (val) map in a special dict, _VAL reference', function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.map, "_VAL": [[[], []]]}')
 | 
			
		||||
    execute('call add(todump._VAL[0][1], todump._VAL)')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.map, "_VAL": [[[], []]]}')
 | 
			
		||||
    command('call add(todump._VAL[0][1], todump._VAL)')
 | 
			
		||||
    eq('Vim(call):E5005: Unable to dump msgpackdump() argument, index 0: container references itself in key [] at index 0 from special map, index 0',
 | 
			
		||||
       exc_exec('call msgpackdump([todump])'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('fails to dump a recursive (val) special list in a special dict',
 | 
			
		||||
  function()
 | 
			
		||||
    execute('let todump = {"_TYPE": v:msgpack_types.array, "_VAL": []}')
 | 
			
		||||
    execute('call add(todump._VAL, [0, todump._VAL])')
 | 
			
		||||
    command('let todump = {"_TYPE": v:msgpack_types.array, "_VAL": []}')
 | 
			
		||||
    command('call add(todump._VAL, [0, todump._VAL])')
 | 
			
		||||
    eq('Vim(call):E5005: Unable to dump msgpackdump() argument, index 0: container references itself in index 0, index 1',
 | 
			
		||||
       exc_exec('call msgpackdump([todump])'))
 | 
			
		||||
  end)
 | 
			
		||||
@@ -689,7 +690,7 @@ describe('msgpackdump() function', function()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('fails to dump a partial', function()
 | 
			
		||||
    execute('function T() dict\nendfunction')
 | 
			
		||||
    command('function T() dict\nendfunction')
 | 
			
		||||
    eq('Vim(call):E686: Argument of msgpackdump() must be a List',
 | 
			
		||||
       exc_exec('call msgpackdump(function("T", [1, 2], {}))'))
 | 
			
		||||
  end)
 | 
			
		||||
 
 | 
			
		||||
@@ -1,6 +1,6 @@
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear, eq, ok = helpers.clear,  helpers.eq, helpers.ok
 | 
			
		||||
local neq, execute, funcs  = helpers.neq, helpers.execute, helpers.funcs
 | 
			
		||||
local neq, command, funcs  = helpers.neq, helpers.command, helpers.funcs
 | 
			
		||||
local reltime, reltimestr, reltimefloat = funcs.reltime, funcs.reltimestr, funcs.reltimefloat
 | 
			
		||||
 | 
			
		||||
describe('reltimestr(), reltimefloat()', function()
 | 
			
		||||
@@ -8,7 +8,7 @@ describe('reltimestr(), reltimefloat()', function()
 | 
			
		||||
 | 
			
		||||
  it('Checks', function()
 | 
			
		||||
    local now = reltime()
 | 
			
		||||
    execute('sleep 10m')
 | 
			
		||||
    command('sleep 10m')
 | 
			
		||||
    local later = reltime()
 | 
			
		||||
    local elapsed = reltime(now)
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
@@ -3,7 +3,7 @@ local setpos = helpers.funcs.setpos
 | 
			
		||||
local getpos = helpers.funcs.getpos
 | 
			
		||||
local insert = helpers.insert
 | 
			
		||||
local clear = helpers.clear
 | 
			
		||||
local execute = helpers.execute
 | 
			
		||||
local command = helpers.command
 | 
			
		||||
local eval = helpers.eval
 | 
			
		||||
local eq = helpers.eq
 | 
			
		||||
local exc_exec = helpers.exc_exec
 | 
			
		||||
@@ -16,7 +16,7 @@ describe('setpos() function', function()
 | 
			
		||||
    First line of text
 | 
			
		||||
    Second line of text
 | 
			
		||||
    Third line of text]])
 | 
			
		||||
    execute('new')
 | 
			
		||||
    command('new')
 | 
			
		||||
    insert([[
 | 
			
		||||
    Line of text 1
 | 
			
		||||
    Line of text 2
 | 
			
		||||
@@ -34,7 +34,8 @@ describe('setpos() function', function()
 | 
			
		||||
  it('can set lowercase marks in the current buffer', function()
 | 
			
		||||
    setpos("'d", {0, 2, 1, 0})
 | 
			
		||||
    eq(getpos("'d"), {0, 2, 1, 0})
 | 
			
		||||
    execute('undo', 'call setpos("\'d", [2, 3, 1, 0])')
 | 
			
		||||
    command('undo')
 | 
			
		||||
    command('call setpos("\'d", [2, 3, 1, 0])')
 | 
			
		||||
    eq(getpos("'d"), {0, 3, 1, 0})
 | 
			
		||||
  end)
 | 
			
		||||
  it('can set lowercase marks in other buffers', function()
 | 
			
		||||
@@ -42,7 +43,7 @@ describe('setpos() function', function()
 | 
			
		||||
    eq(0, retval)
 | 
			
		||||
    setpos("'d", {1, 2, 1, 0})
 | 
			
		||||
    eq(getpos("'d"), {0, 0, 0, 0})
 | 
			
		||||
    execute('wincmd w')
 | 
			
		||||
    command('wincmd w')
 | 
			
		||||
    eq(eval('bufnr("%")'), 1)
 | 
			
		||||
    eq(getpos("'d"), {0, 2, 1, 0})
 | 
			
		||||
  end)
 | 
			
		||||
 
 | 
			
		||||
@@ -1,6 +1,6 @@
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local exc_exec = helpers.exc_exec
 | 
			
		||||
local execute = helpers.execute
 | 
			
		||||
local command = helpers.command
 | 
			
		||||
local funcs = helpers.funcs
 | 
			
		||||
local clear = helpers.clear
 | 
			
		||||
local eval = helpers.eval
 | 
			
		||||
@@ -12,7 +12,7 @@ describe('Special values', function()
 | 
			
		||||
  before_each(clear)
 | 
			
		||||
 | 
			
		||||
  it('do not cause error when freed', function()
 | 
			
		||||
    execute([[
 | 
			
		||||
    command([[
 | 
			
		||||
      function Test()
 | 
			
		||||
        try
 | 
			
		||||
          return v:true
 | 
			
		||||
@@ -109,7 +109,7 @@ describe('Special values', function()
 | 
			
		||||
  it('does not work with +=/-=/.=', function()
 | 
			
		||||
    meths.set_var('true', true)
 | 
			
		||||
    meths.set_var('false', false)
 | 
			
		||||
    execute('let null = v:null')
 | 
			
		||||
    command('let null = v:null')
 | 
			
		||||
 | 
			
		||||
    eq('Vim(let):E734: Wrong variable type for +=', exc_exec('let true  += 1'))
 | 
			
		||||
    eq('Vim(let):E734: Wrong variable type for +=', exc_exec('let false += 1'))
 | 
			
		||||
 
 | 
			
		||||
@@ -1,6 +1,6 @@
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local eq, call, clear, eval, execute, feed, nvim =
 | 
			
		||||
  helpers.eq, helpers.call, helpers.clear, helpers.eval, helpers.execute,
 | 
			
		||||
local eq, call, clear, eval, feed_command, feed, nvim =
 | 
			
		||||
  helpers.eq, helpers.call, helpers.clear, helpers.eval, helpers.feed_command,
 | 
			
		||||
  helpers.feed, helpers.nvim
 | 
			
		||||
 | 
			
		||||
local Screen = require('test.functional.ui.screen')
 | 
			
		||||
@@ -43,10 +43,10 @@ describe('system()', function()
 | 
			
		||||
    it('parameter validation does NOT modify v:shell_error', function()
 | 
			
		||||
      -- 1. Call system() with invalid parameters.
 | 
			
		||||
      -- 2. Assert that v:shell_error was NOT set.
 | 
			
		||||
      execute('call system({})')
 | 
			
		||||
      feed_command('call system({})')
 | 
			
		||||
      eq('E475: Invalid argument: expected String or List', eval('v:errmsg'))
 | 
			
		||||
      eq(0, eval('v:shell_error'))
 | 
			
		||||
      execute('call system([])')
 | 
			
		||||
      feed_command('call system([])')
 | 
			
		||||
      eq('E474: Invalid argument', eval('v:errmsg'))
 | 
			
		||||
      eq(0, eval('v:shell_error'))
 | 
			
		||||
 | 
			
		||||
@@ -57,9 +57,9 @@ describe('system()', function()
 | 
			
		||||
 | 
			
		||||
      -- 1. Call system() with invalid parameters.
 | 
			
		||||
      -- 2. Assert that v:shell_error was NOT modified.
 | 
			
		||||
      execute('call system({})')
 | 
			
		||||
      feed_command('call system({})')
 | 
			
		||||
      eq(old_val, eval('v:shell_error'))
 | 
			
		||||
      execute('call system([])')
 | 
			
		||||
      feed_command('call system([])')
 | 
			
		||||
      eq(old_val, eval('v:shell_error'))
 | 
			
		||||
    end)
 | 
			
		||||
 | 
			
		||||
@@ -182,7 +182,7 @@ describe('system()', function()
 | 
			
		||||
    end)
 | 
			
		||||
    it('to backgrounded command does not crash', function()
 | 
			
		||||
      -- This is indeterminate, just exercise the codepath. May get E5677.
 | 
			
		||||
      execute('call system("echo -n echoed &")')
 | 
			
		||||
      feed_command('call system("echo -n echoed &")')
 | 
			
		||||
      local v_errnum = string.match(eval("v:errmsg"), "^E%d*:")
 | 
			
		||||
      if v_errnum then
 | 
			
		||||
        eq("E5677:", v_errnum)
 | 
			
		||||
@@ -197,7 +197,7 @@ describe('system()', function()
 | 
			
		||||
    end)
 | 
			
		||||
    it('to backgrounded command does not crash', function()
 | 
			
		||||
      -- This is indeterminate, just exercise the codepath. May get E5677.
 | 
			
		||||
      execute('call system("cat - &")')
 | 
			
		||||
      feed_command('call system("cat - &")')
 | 
			
		||||
      local v_errnum = string.match(eval("v:errmsg"), "^E%d*:")
 | 
			
		||||
      if v_errnum then
 | 
			
		||||
        eq("E5677:", v_errnum)
 | 
			
		||||
 
 | 
			
		||||
@@ -2,7 +2,7 @@ local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local Screen = require('test.functional.ui.screen')
 | 
			
		||||
local ok, feed, eq, eval = helpers.ok, helpers.feed, helpers.eq, helpers.eval
 | 
			
		||||
local source, nvim_async, run = helpers.source, helpers.nvim_async, helpers.run
 | 
			
		||||
local clear, execute, funcs = helpers.clear, helpers.execute, helpers.funcs
 | 
			
		||||
local clear, command, funcs = helpers.clear, helpers.command, helpers.funcs
 | 
			
		||||
local curbufmeths = helpers.curbufmeths
 | 
			
		||||
 | 
			
		||||
describe('timers', function()
 | 
			
		||||
@@ -17,14 +17,14 @@ describe('timers', function()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('works one-shot', function()
 | 
			
		||||
    execute("call timer_start(50, 'MyHandler')")
 | 
			
		||||
    command("call timer_start(50, 'MyHandler')")
 | 
			
		||||
    eq(0,eval("g:val"))
 | 
			
		||||
    run(nil, nil, nil, 200)
 | 
			
		||||
    eq(1,eval("g:val"))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('works one-shot when repeat=0', function()
 | 
			
		||||
    execute("call timer_start(50, 'MyHandler', {'repeat': 0})")
 | 
			
		||||
    command("call timer_start(50, 'MyHandler', {'repeat': 0})")
 | 
			
		||||
    eq(0,eval("g:val"))
 | 
			
		||||
    run(nil, nil, nil, 200)
 | 
			
		||||
    eq(1,eval("g:val"))
 | 
			
		||||
@@ -32,14 +32,14 @@ describe('timers', function()
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
  it('works with repeat two', function()
 | 
			
		||||
    execute("call timer_start(50, 'MyHandler', {'repeat': 2})")
 | 
			
		||||
    command("call timer_start(50, 'MyHandler', {'repeat': 2})")
 | 
			
		||||
    eq(0,eval("g:val"))
 | 
			
		||||
    run(nil, nil, nil, 300)
 | 
			
		||||
    eq(2,eval("g:val"))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('are triggered during sleep', function()
 | 
			
		||||
    execute("call timer_start(50, 'MyHandler', {'repeat': 2})")
 | 
			
		||||
    command("call timer_start(50, 'MyHandler', {'repeat': 2})")
 | 
			
		||||
    nvim_async("command", "sleep 10")
 | 
			
		||||
    eq(0,eval("g:val"))
 | 
			
		||||
    run(nil, nil, nil, 300)
 | 
			
		||||
@@ -63,12 +63,12 @@ describe('timers', function()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('are paused when event processing is disabled', function()
 | 
			
		||||
    execute("call timer_start(50, 'MyHandler', {'repeat': -1})")
 | 
			
		||||
    command("call timer_start(50, 'MyHandler', {'repeat': -1})")
 | 
			
		||||
    run(nil, nil, nil, 100)
 | 
			
		||||
    local count = eval("g:val")
 | 
			
		||||
    -- shows two line error message and thus invokes the return prompt.
 | 
			
		||||
    -- if we start to allow event processing here, we need to change this test.
 | 
			
		||||
    execute("throw 'fatal error'")
 | 
			
		||||
    feed(':throw "fatal error"<CR>')
 | 
			
		||||
    run(nil, nil, nil, 300)
 | 
			
		||||
    feed("<cr>")
 | 
			
		||||
    local diff = eval("g:val") - count
 | 
			
		||||
@@ -76,7 +76,7 @@ describe('timers', function()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('are triggered in blocking getchar() call', function()
 | 
			
		||||
    execute("call timer_start(50, 'MyHandler', {'repeat': -1})")
 | 
			
		||||
    command("call timer_start(50, 'MyHandler', {'repeat': -1})")
 | 
			
		||||
    nvim_async("command", "let g:c = getchar()")
 | 
			
		||||
    run(nil, nil, nil, 300)
 | 
			
		||||
    feed("c")
 | 
			
		||||
@@ -157,7 +157,7 @@ describe('timers', function()
 | 
			
		||||
        endif
 | 
			
		||||
      endfunc
 | 
			
		||||
    ]])
 | 
			
		||||
    execute("call timer_start(50, 'MyHandler', {'repeat': -1})")
 | 
			
		||||
    command("call timer_start(50, 'MyHandler', {'repeat': -1})")
 | 
			
		||||
    eq(0,eval("g:val"))
 | 
			
		||||
    run(nil, nil, nil, 300)
 | 
			
		||||
    eq(3,eval("g:val"))
 | 
			
		||||
@@ -170,8 +170,8 @@ describe('timers', function()
 | 
			
		||||
        let g:val2 += 1
 | 
			
		||||
      endfunc
 | 
			
		||||
    ]])
 | 
			
		||||
    execute("call timer_start(50,  'MyHandler', {'repeat': 3})")
 | 
			
		||||
    execute("call timer_start(100, 'MyHandler2', {'repeat': 2})")
 | 
			
		||||
    command("call timer_start(50,  'MyHandler', {'repeat': 3})")
 | 
			
		||||
    command("call timer_start(100, 'MyHandler2', {'repeat': 2})")
 | 
			
		||||
    run(nil, nil, nil, 300)
 | 
			
		||||
    eq(3,eval("g:val"))
 | 
			
		||||
    eq(2,eval("g:val2"))
 | 
			
		||||
@@ -186,7 +186,7 @@ describe('timers', function()
 | 
			
		||||
        let g:val += 1
 | 
			
		||||
      endfunc
 | 
			
		||||
    ]])
 | 
			
		||||
    execute("call timer_start(5, 'MyHandler', {'repeat': 1})")
 | 
			
		||||
    command("call timer_start(5, 'MyHandler', {'repeat': 1})")
 | 
			
		||||
    run(nil, nil, nil, 300)
 | 
			
		||||
    eq(1,eval("g:val"))
 | 
			
		||||
  end)
 | 
			
		||||
@@ -201,7 +201,7 @@ describe('timers', function()
 | 
			
		||||
        echo "evil"
 | 
			
		||||
      endfunc
 | 
			
		||||
    ]])
 | 
			
		||||
    execute("call timer_start(100,  'MyHandler', {'repeat': 1})")
 | 
			
		||||
    command("call timer_start(100,  'MyHandler', {'repeat': 1})")
 | 
			
		||||
    feed(":good")
 | 
			
		||||
    screen:sleep(200)
 | 
			
		||||
    screen:expect([[
 | 
			
		||||
 
 | 
			
		||||
@@ -1,5 +1,5 @@
 | 
			
		||||
local helpers = require("test.functional.helpers")(after_each)
 | 
			
		||||
local eq, execute, funcs = helpers.eq, helpers.execute, helpers.funcs
 | 
			
		||||
local eq, command, funcs = helpers.eq, helpers.command, helpers.funcs
 | 
			
		||||
local ok = helpers.ok
 | 
			
		||||
local clear = helpers.clear
 | 
			
		||||
 | 
			
		||||
@@ -9,15 +9,15 @@ describe(":argument", function()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it("does not restart :terminal buffer", function()
 | 
			
		||||
      execute("terminal")
 | 
			
		||||
      command("terminal")
 | 
			
		||||
      helpers.feed([[<C-\><C-N>]])
 | 
			
		||||
      execute("argadd")
 | 
			
		||||
      command("argadd")
 | 
			
		||||
      helpers.feed([[<C-\><C-N>]])
 | 
			
		||||
      local bufname_before = funcs.bufname("%")
 | 
			
		||||
      local bufnr_before = funcs.bufnr("%")
 | 
			
		||||
      helpers.ok(nil ~= string.find(bufname_before, "^term://"))  -- sanity
 | 
			
		||||
 | 
			
		||||
      execute("argument 1")
 | 
			
		||||
      command("argument 1")
 | 
			
		||||
      helpers.feed([[<C-\><C-N>]])
 | 
			
		||||
 | 
			
		||||
      local bufname_after = funcs.bufname("%")
 | 
			
		||||
 
 | 
			
		||||
@@ -1,7 +1,7 @@
 | 
			
		||||
-- Specs for bang/filter commands
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local feed, execute, clear = helpers.feed, helpers.execute, helpers.clear
 | 
			
		||||
local feed, command, clear = helpers.feed, helpers.command, helpers.clear
 | 
			
		||||
local mkdir, write_file, rmdir = helpers.mkdir, helpers.write_file, helpers.rmdir
 | 
			
		||||
 | 
			
		||||
if helpers.pending_win32(pending) then return end
 | 
			
		||||
@@ -28,7 +28,7 @@ describe('issues', function()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('#3269 Last line of shell output is not truncated', function()
 | 
			
		||||
    execute([[nnoremap <silent>\l :!ls bang_filter_spec<cr>]])
 | 
			
		||||
    command([[nnoremap <silent>\l :!ls bang_filter_spec<cr>]])
 | 
			
		||||
    feed([[\l]])
 | 
			
		||||
    screen:expect([[
 | 
			
		||||
      ~                                                    |
 | 
			
		||||
 
 | 
			
		||||
@@ -6,7 +6,7 @@ local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local eq = helpers.eq
 | 
			
		||||
local call = helpers.call
 | 
			
		||||
local clear = helpers.clear
 | 
			
		||||
local execute = helpers.execute
 | 
			
		||||
local command = helpers.command
 | 
			
		||||
local exc_exec = helpers.exc_exec
 | 
			
		||||
 | 
			
		||||
if helpers.pending_win32(pending) then return end
 | 
			
		||||
@@ -58,7 +58,7 @@ for _, cmd in ipairs {'cd', 'chdir'} do
 | 
			
		||||
        eq(0, lwd(globalwin))
 | 
			
		||||
        eq(0, lwd(globalwin, tabnr))
 | 
			
		||||
 | 
			
		||||
        execute('bot split')
 | 
			
		||||
        command('bot split')
 | 
			
		||||
        local localwin = call('winnr')
 | 
			
		||||
        -- Initial window is still using globalDir
 | 
			
		||||
        eq(globalDir, cwd(localwin))
 | 
			
		||||
@@ -66,7 +66,7 @@ for _, cmd in ipairs {'cd', 'chdir'} do
 | 
			
		||||
        eq(0, lwd(globalwin))
 | 
			
		||||
        eq(0, lwd(globalwin, tabnr))
 | 
			
		||||
 | 
			
		||||
        execute('silent l' .. cmd .. ' ' .. directories.window)
 | 
			
		||||
        command('silent l' .. cmd .. ' ' .. directories.window)
 | 
			
		||||
        -- From window with local dir, the original window
 | 
			
		||||
        -- is still reporting the global dir
 | 
			
		||||
        eq(globalDir, cwd(globalwin))
 | 
			
		||||
@@ -80,7 +80,7 @@ for _, cmd in ipairs {'cd', 'chdir'} do
 | 
			
		||||
        eq(1, lwd(localwin))
 | 
			
		||||
        eq(1, lwd(localwin, tabnr))
 | 
			
		||||
 | 
			
		||||
        execute('tabnew')
 | 
			
		||||
        command('tabnew')
 | 
			
		||||
        -- From new tab page, original window reports global dir
 | 
			
		||||
        eq(globalDir, cwd(globalwin, tabnr))
 | 
			
		||||
        eq(0, lwd(globalwin, tabnr))
 | 
			
		||||
@@ -100,8 +100,8 @@ for _, cmd in ipairs {'cd', 'chdir'} do
 | 
			
		||||
        eq(0, lwd(-1, 0))
 | 
			
		||||
        eq(0, lwd(-1, globaltab))
 | 
			
		||||
 | 
			
		||||
        execute('tabnew')
 | 
			
		||||
        execute('silent t' .. cmd .. ' ' .. directories.tab)
 | 
			
		||||
        command('tabnew')
 | 
			
		||||
        command('silent t' .. cmd .. ' ' .. directories.tab)
 | 
			
		||||
        local localtab = call('tabpagenr')
 | 
			
		||||
 | 
			
		||||
        -- From local tab page, original tab reports globalDir
 | 
			
		||||
@@ -114,7 +114,7 @@ for _, cmd in ipairs {'cd', 'chdir'} do
 | 
			
		||||
        eq(1, lwd(-1, 0))
 | 
			
		||||
        eq(1, lwd(-1, localtab))
 | 
			
		||||
 | 
			
		||||
        execute('tabnext')
 | 
			
		||||
        command('tabnext')
 | 
			
		||||
        -- From original tab page, local reports as such
 | 
			
		||||
        eq(globalDir .. '/' .. directories.tab, cwd(-1, localtab))
 | 
			
		||||
        eq(1, lwd(-1, localtab))
 | 
			
		||||
@@ -128,13 +128,13 @@ for _, cmd in ipairs {'cd', 'chdir'} do
 | 
			
		||||
      end)
 | 
			
		||||
 | 
			
		||||
      it('works with tab-local pwd', function()
 | 
			
		||||
        execute('silent t' .. cmd .. ' ' .. directories.tab)
 | 
			
		||||
        command('silent t' .. cmd .. ' ' .. directories.tab)
 | 
			
		||||
        eq(directories.start, cwd(-1, -1))
 | 
			
		||||
        eq(0, lwd(-1, -1))
 | 
			
		||||
      end)
 | 
			
		||||
 | 
			
		||||
      it('works with window-local pwd', function()
 | 
			
		||||
        execute('silent l' .. cmd .. ' ' .. directories.window)
 | 
			
		||||
        command('silent l' .. cmd .. ' ' .. directories.window)
 | 
			
		||||
        eq(directories.start, cwd(-1, -1))
 | 
			
		||||
        eq(0, lwd(-1, -1))
 | 
			
		||||
      end)
 | 
			
		||||
@@ -145,18 +145,18 @@ for _, cmd in ipairs {'cd', 'chdir'} do
 | 
			
		||||
        local globalDir = directories.start
 | 
			
		||||
 | 
			
		||||
        -- Create a new tab and change directory
 | 
			
		||||
        execute('tabnew')
 | 
			
		||||
        execute('silent t' .. cmd .. ' ' .. directories.tab)
 | 
			
		||||
        command('tabnew')
 | 
			
		||||
        command('silent t' .. cmd .. ' ' .. directories.tab)
 | 
			
		||||
        eq(globalDir .. '/' .. directories.tab, tcwd())
 | 
			
		||||
 | 
			
		||||
        -- Create a new tab and verify it has inherited the directory
 | 
			
		||||
        execute('tabnew')
 | 
			
		||||
        command('tabnew')
 | 
			
		||||
        eq(globalDir .. '/' .. directories.tab, tcwd())
 | 
			
		||||
 | 
			
		||||
        -- Change tab and change back, verify that directories are correct
 | 
			
		||||
        execute('tabnext')
 | 
			
		||||
        command('tabnext')
 | 
			
		||||
        eq(globalDir, tcwd())
 | 
			
		||||
        execute('tabprevious')
 | 
			
		||||
        command('tabprevious')
 | 
			
		||||
        eq(globalDir .. '/' .. directories.tab, tcwd())
 | 
			
		||||
      end)
 | 
			
		||||
    end)
 | 
			
		||||
@@ -164,7 +164,7 @@ for _, cmd in ipairs {'cd', 'chdir'} do
 | 
			
		||||
    it('works', function()
 | 
			
		||||
      local globalDir = directories.start
 | 
			
		||||
      -- Create a new tab first and verify that is has the same working dir
 | 
			
		||||
      execute('tabnew')
 | 
			
		||||
      command('tabnew')
 | 
			
		||||
      eq(globalDir, cwd())
 | 
			
		||||
      eq(globalDir, tcwd())  -- has no tab-local directory
 | 
			
		||||
      eq(0, tlwd())
 | 
			
		||||
@@ -172,7 +172,7 @@ for _, cmd in ipairs {'cd', 'chdir'} do
 | 
			
		||||
      eq(0, wlwd())
 | 
			
		||||
 | 
			
		||||
      -- Change tab-local working directory and verify it is different
 | 
			
		||||
      execute('silent t' .. cmd .. ' ' .. directories.tab)
 | 
			
		||||
      command('silent t' .. cmd .. ' ' .. directories.tab)
 | 
			
		||||
      eq(globalDir .. '/' .. directories.tab, cwd())
 | 
			
		||||
      eq(cwd(), tcwd())  -- working directory maches tab directory
 | 
			
		||||
      eq(1, tlwd())
 | 
			
		||||
@@ -180,46 +180,46 @@ for _, cmd in ipairs {'cd', 'chdir'} do
 | 
			
		||||
      eq(0, wlwd())
 | 
			
		||||
 | 
			
		||||
      -- Create a new window in this tab to test `:lcd`
 | 
			
		||||
      execute('new')
 | 
			
		||||
      command('new')
 | 
			
		||||
      eq(1, tlwd())  -- Still tab-local working directory
 | 
			
		||||
      eq(0, wlwd())  -- Still no window-local working directory
 | 
			
		||||
      eq(globalDir .. '/' .. directories.tab, cwd())
 | 
			
		||||
      execute('silent l' .. cmd .. ' ../' .. directories.window)
 | 
			
		||||
      command('silent l' .. cmd .. ' ../' .. directories.window)
 | 
			
		||||
      eq(globalDir .. '/' .. directories.window, cwd())
 | 
			
		||||
      eq(globalDir .. '/' .. directories.tab, tcwd())
 | 
			
		||||
      eq(1, wlwd())
 | 
			
		||||
 | 
			
		||||
      -- Verify the first window still has the tab local directory
 | 
			
		||||
      execute('wincmd w')
 | 
			
		||||
      command('wincmd w')
 | 
			
		||||
      eq(globalDir .. '/' .. directories.tab,  cwd())
 | 
			
		||||
      eq(globalDir .. '/' .. directories.tab, tcwd())
 | 
			
		||||
      eq(0, wlwd())  -- No window-local directory
 | 
			
		||||
 | 
			
		||||
      -- Change back to initial tab and verify working directory has stayed
 | 
			
		||||
      execute('tabnext')
 | 
			
		||||
      command('tabnext')
 | 
			
		||||
      eq(globalDir, cwd() )
 | 
			
		||||
      eq(0, tlwd())
 | 
			
		||||
      eq(0, wlwd())
 | 
			
		||||
 | 
			
		||||
      -- Verify global changes don't affect local ones
 | 
			
		||||
      execute('silent ' .. cmd .. ' ' .. directories.global)
 | 
			
		||||
      command('silent ' .. cmd .. ' ' .. directories.global)
 | 
			
		||||
      eq(globalDir .. '/' .. directories.global, cwd())
 | 
			
		||||
      execute('tabnext')
 | 
			
		||||
      command('tabnext')
 | 
			
		||||
      eq(globalDir .. '/' .. directories.tab,  cwd())
 | 
			
		||||
      eq(globalDir .. '/' .. directories.tab, tcwd())
 | 
			
		||||
      eq(0, wlwd())  -- Still no window-local directory in this window
 | 
			
		||||
 | 
			
		||||
      -- Unless the global change happened in a tab with local directory
 | 
			
		||||
      execute('silent ' .. cmd .. ' ..')
 | 
			
		||||
      command('silent ' .. cmd .. ' ..')
 | 
			
		||||
      eq(globalDir, cwd() )
 | 
			
		||||
      eq(0 , tlwd())
 | 
			
		||||
      eq(0 , wlwd())
 | 
			
		||||
      -- Which also affects the first tab
 | 
			
		||||
      execute('tabnext')
 | 
			
		||||
      command('tabnext')
 | 
			
		||||
      eq(globalDir, cwd())
 | 
			
		||||
 | 
			
		||||
      -- But not in a window with its own local directory
 | 
			
		||||
      execute('tabnext | wincmd w')
 | 
			
		||||
      command('tabnext | wincmd w')
 | 
			
		||||
      eq(globalDir .. '/' .. directories.window, cwd() )
 | 
			
		||||
      eq(0 , tlwd())
 | 
			
		||||
      eq(globalDir .. '/' .. directories.window, wcwd())
 | 
			
		||||
@@ -280,8 +280,8 @@ describe("getcwd()", function ()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it("returns empty string if working directory does not exist", function()
 | 
			
		||||
    execute("cd "..directories.global)
 | 
			
		||||
    execute("call delete('../"..directories.global.."', 'd')")
 | 
			
		||||
    command("cd "..directories.global)
 | 
			
		||||
    command("call delete('../"..directories.global.."', 'd')")
 | 
			
		||||
    eq("", helpers.eval("getcwd()"))
 | 
			
		||||
  end)
 | 
			
		||||
end)
 | 
			
		||||
 
 | 
			
		||||
@@ -1,7 +1,7 @@
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local Screen = require('test.functional.ui.screen')
 | 
			
		||||
local clear, feed, source = helpers.clear, helpers.feed, helpers.source
 | 
			
		||||
local execute = helpers.execute
 | 
			
		||||
local command = helpers.command
 | 
			
		||||
 | 
			
		||||
describe("CTRL-C (mapped)", function()
 | 
			
		||||
  before_each(function()
 | 
			
		||||
@@ -20,7 +20,7 @@ describe("CTRL-C (mapped)", function()
 | 
			
		||||
      nnoremap <C-C> <NOP>
 | 
			
		||||
    ]])
 | 
			
		||||
 | 
			
		||||
    execute("silent edit! test/functional/fixtures/bigfile.txt")
 | 
			
		||||
    command("silent edit! test/functional/fixtures/bigfile.txt")
 | 
			
		||||
    local screen = Screen.new(52, 6)
 | 
			
		||||
    screen:attach()
 | 
			
		||||
    screen:set_default_attr_ids({
 | 
			
		||||
 
 | 
			
		||||
@@ -1,6 +1,6 @@
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local Screen = require('test.functional.ui.screen')
 | 
			
		||||
local clear, feed, execute = helpers.clear, helpers.feed, helpers.execute
 | 
			
		||||
local clear, feed, feed_command = helpers.clear, helpers.feed, helpers.feed_command
 | 
			
		||||
 | 
			
		||||
describe(":drop", function()
 | 
			
		||||
  local screen
 | 
			
		||||
@@ -15,7 +15,7 @@ describe(":drop", function()
 | 
			
		||||
      [2] = {reverse = true},
 | 
			
		||||
      [3] = {bold = true},
 | 
			
		||||
    })
 | 
			
		||||
    execute("set laststatus=2")
 | 
			
		||||
    feed_command("set laststatus=2")
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  after_each(function()
 | 
			
		||||
@@ -23,7 +23,7 @@ describe(":drop", function()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it("works like :e when called with only one window open", function()
 | 
			
		||||
    execute("drop tmp1.vim")
 | 
			
		||||
    feed_command("drop tmp1.vim")
 | 
			
		||||
    screen:expect([[
 | 
			
		||||
      ^                                   |
 | 
			
		||||
      {0:~                                  }|
 | 
			
		||||
@@ -39,10 +39,10 @@ describe(":drop", function()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it("switches to an open window showing the buffer", function()
 | 
			
		||||
    execute("edit tmp1")
 | 
			
		||||
    execute("vsplit")
 | 
			
		||||
    execute("edit tmp2")
 | 
			
		||||
    execute("drop tmp1")
 | 
			
		||||
    feed_command("edit tmp1")
 | 
			
		||||
    feed_command("vsplit")
 | 
			
		||||
    feed_command("edit tmp2")
 | 
			
		||||
    feed_command("drop tmp1")
 | 
			
		||||
    screen:expect([[
 | 
			
		||||
                    {2:|}^                    |
 | 
			
		||||
      {0:~             }{2:|}{0:~                   }|
 | 
			
		||||
@@ -58,11 +58,11 @@ describe(":drop", function()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it("splits off a new window when a buffer can't be abandoned", function()
 | 
			
		||||
    execute("edit tmp1")
 | 
			
		||||
    execute("vsplit")
 | 
			
		||||
    execute("edit tmp2")
 | 
			
		||||
    feed_command("edit tmp1")
 | 
			
		||||
    feed_command("vsplit")
 | 
			
		||||
    feed_command("edit tmp2")
 | 
			
		||||
    feed("iABC<esc>")
 | 
			
		||||
    execute("drop tmp3")
 | 
			
		||||
    feed_command("drop tmp3")
 | 
			
		||||
    screen:expect([[
 | 
			
		||||
      ^                    {2:|}              |
 | 
			
		||||
      {0:~                   }{2:|}{0:~             }|
 | 
			
		||||
 
 | 
			
		||||
@@ -1,7 +1,8 @@
 | 
			
		||||
local helpers = require("test.functional.helpers")(after_each)
 | 
			
		||||
local eq, execute, funcs = helpers.eq, helpers.execute, helpers.funcs
 | 
			
		||||
local eq, command, funcs = helpers.eq, helpers.command, helpers.funcs
 | 
			
		||||
local ok = helpers.ok
 | 
			
		||||
local clear = helpers.clear
 | 
			
		||||
local feed = helpers.feed
 | 
			
		||||
 | 
			
		||||
describe(":edit", function()
 | 
			
		||||
  before_each(function()
 | 
			
		||||
@@ -9,13 +10,13 @@ describe(":edit", function()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it("without arguments does not restart :terminal buffer", function()
 | 
			
		||||
      execute("terminal")
 | 
			
		||||
      helpers.feed([[<C-\><C-N>]])
 | 
			
		||||
      command("terminal")
 | 
			
		||||
      feed([[<C-\><C-N>]])
 | 
			
		||||
      local bufname_before = funcs.bufname("%")
 | 
			
		||||
      local bufnr_before = funcs.bufnr("%")
 | 
			
		||||
      helpers.ok(nil ~= string.find(bufname_before, "^term://"))  -- sanity
 | 
			
		||||
 | 
			
		||||
      execute("edit")
 | 
			
		||||
      command("edit")
 | 
			
		||||
 | 
			
		||||
      local bufname_after = funcs.bufname("%")
 | 
			
		||||
      local bufnr_after = funcs.bufnr("%")
 | 
			
		||||
 
 | 
			
		||||
@@ -1,5 +1,5 @@
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear, execute, feed = helpers.clear, helpers.execute, helpers.feed
 | 
			
		||||
local clear, feed_command, feed = helpers.clear, helpers.feed_command, helpers.feed
 | 
			
		||||
local eq, neq, eval = helpers.eq, helpers.neq, helpers.eval
 | 
			
		||||
 | 
			
		||||
describe('&encoding', function()
 | 
			
		||||
@@ -12,7 +12,7 @@ describe('&encoding', function()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('cannot be changed after setup', function()
 | 
			
		||||
    execute('set encoding=latin1')
 | 
			
		||||
    feed_command('set encoding=latin1')
 | 
			
		||||
    -- error message expected
 | 
			
		||||
    feed('<cr>')
 | 
			
		||||
    neq(nil, string.find(eval('v:errmsg'), '^E474:'))
 | 
			
		||||
@@ -31,7 +31,7 @@ describe('&encoding', function()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('can be set to utf-8 without error', function()
 | 
			
		||||
    execute('set encoding=utf-8')
 | 
			
		||||
    feed_command('set encoding=utf-8')
 | 
			
		||||
    eq("", eval('v:errmsg'))
 | 
			
		||||
 | 
			
		||||
    clear('--cmd', 'set enc=utf-8')
 | 
			
		||||
 
 | 
			
		||||
@@ -1,6 +1,6 @@
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear, execute, feed, ok, eval =
 | 
			
		||||
  helpers.clear, helpers.execute, helpers.feed, helpers.ok, helpers.eval
 | 
			
		||||
local clear, feed_command, feed, ok, eval =
 | 
			
		||||
  helpers.clear, helpers.feed_command, helpers.feed, helpers.ok, helpers.eval
 | 
			
		||||
 | 
			
		||||
describe(':grep', function()
 | 
			
		||||
  before_each(clear)
 | 
			
		||||
@@ -11,10 +11,10 @@ describe(':grep', function()
 | 
			
		||||
      return
 | 
			
		||||
    end
 | 
			
		||||
 | 
			
		||||
    execute([[set grepprg=grep\ -r]])
 | 
			
		||||
    feed_command([[set grepprg=grep\ -r]])
 | 
			
		||||
    -- Change to test directory so that the test does not run too long.
 | 
			
		||||
    execute('cd test')
 | 
			
		||||
    execute('grep a **/*')
 | 
			
		||||
    feed_command('cd test')
 | 
			
		||||
    feed_command('grep a **/*')
 | 
			
		||||
    feed('<cr>')  -- Press ENTER
 | 
			
		||||
    ok(eval('len(getqflist())') > 9000)  -- IT'S OVER 9000!!1
 | 
			
		||||
  end)
 | 
			
		||||
 
 | 
			
		||||
@@ -1,5 +1,5 @@
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear, execute, nvim = helpers.clear, helpers.execute, helpers.nvim
 | 
			
		||||
local clear, command, nvim = helpers.clear, helpers.command, helpers.nvim
 | 
			
		||||
local expect, feed, command = helpers.expect, helpers.feed, helpers.command
 | 
			
		||||
local eq, eval = helpers.eq, helpers.eval
 | 
			
		||||
 | 
			
		||||
@@ -7,17 +7,17 @@ describe(':emenu', function()
 | 
			
		||||
 | 
			
		||||
  before_each(function()
 | 
			
		||||
    clear()
 | 
			
		||||
    execute('nnoremenu Test.Test inormal<ESC>')
 | 
			
		||||
    execute('inoremenu Test.Test insert')
 | 
			
		||||
    execute('vnoremenu Test.Test x')
 | 
			
		||||
    execute('cnoremenu Test.Test cmdmode')
 | 
			
		||||
    command('nnoremenu Test.Test inormal<ESC>')
 | 
			
		||||
    command('inoremenu Test.Test insert')
 | 
			
		||||
    command('vnoremenu Test.Test x')
 | 
			
		||||
    command('cnoremenu Test.Test cmdmode')
 | 
			
		||||
 | 
			
		||||
    execute('nnoremenu Edit.Paste p')
 | 
			
		||||
    execute('cnoremenu Edit.Paste <C-R>"')
 | 
			
		||||
    command('nnoremenu Edit.Paste p')
 | 
			
		||||
    command('cnoremenu Edit.Paste <C-R>"')
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('executes correct bindings in normal mode without using API', function()
 | 
			
		||||
    execute('emenu Test.Test')
 | 
			
		||||
    command('emenu Test.Test')
 | 
			
		||||
    expect('normal')
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
@@ -1,7 +1,7 @@
 | 
			
		||||
local Screen = require('test.functional.ui.screen')
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
 | 
			
		||||
local buf, eq, execute = helpers.curbufmeths, helpers.eq, helpers.execute
 | 
			
		||||
local buf, eq, feed_command = helpers.curbufmeths, helpers.eq, helpers.feed_command
 | 
			
		||||
local feed, nvim_prog, wait = helpers.feed, helpers.nvim_prog, helpers.wait
 | 
			
		||||
local ok, set_session, spawn = helpers.ok, helpers.set_session, helpers.spawn
 | 
			
		||||
 | 
			
		||||
@@ -27,12 +27,12 @@ describe(':oldfiles', function()
 | 
			
		||||
  it('shows most recently used files', function()
 | 
			
		||||
    local screen = Screen.new(100, 5)
 | 
			
		||||
    screen:attach()
 | 
			
		||||
    execute('edit testfile1')
 | 
			
		||||
    execute('edit testfile2')
 | 
			
		||||
    execute('wshada ' .. shada_file)
 | 
			
		||||
    execute('rshada! ' .. shada_file)
 | 
			
		||||
    feed_command('edit testfile1')
 | 
			
		||||
    feed_command('edit testfile2')
 | 
			
		||||
    feed_command('wshada ' .. shada_file)
 | 
			
		||||
    feed_command('rshada! ' .. shada_file)
 | 
			
		||||
    local oldfiles = helpers.meths.get_vvar('oldfiles')
 | 
			
		||||
    execute('oldfiles')
 | 
			
		||||
    feed_command('oldfiles')
 | 
			
		||||
    screen:expect([[
 | 
			
		||||
      testfile2                                                                                           |
 | 
			
		||||
      1: ]].. add_padding(oldfiles[1]) ..[[ |
 | 
			
		||||
@@ -50,14 +50,14 @@ describe(':browse oldfiles', function()
 | 
			
		||||
 | 
			
		||||
  before_each(function()
 | 
			
		||||
    _clear()
 | 
			
		||||
    execute('edit testfile1')
 | 
			
		||||
    feed_command('edit testfile1')
 | 
			
		||||
    filename = buf.get_name()
 | 
			
		||||
    execute('edit testfile2')
 | 
			
		||||
    feed_command('edit testfile2')
 | 
			
		||||
    filename2 = buf.get_name()
 | 
			
		||||
    execute('wshada ' .. shada_file)
 | 
			
		||||
    feed_command('wshada ' .. shada_file)
 | 
			
		||||
    wait()
 | 
			
		||||
    _clear()
 | 
			
		||||
    execute('rshada! ' .. shada_file)
 | 
			
		||||
    feed_command('rshada! ' .. shada_file)
 | 
			
		||||
 | 
			
		||||
    -- Ensure nvim is out of "Press ENTER..." prompt.
 | 
			
		||||
    feed('<cr>')
 | 
			
		||||
@@ -70,7 +70,7 @@ describe(':browse oldfiles', function()
 | 
			
		||||
    ok(filename == oldfiles[1] or filename == oldfiles[2])
 | 
			
		||||
    ok(filename2 == oldfiles[1] or filename2 == oldfiles[2])
 | 
			
		||||
 | 
			
		||||
    execute('browse oldfiles')
 | 
			
		||||
    feed_command('browse oldfiles')
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  after_each(function()
 | 
			
		||||
 
 | 
			
		||||
@@ -2,8 +2,8 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local lfs = require('lfs')
 | 
			
		||||
local execute, eq, clear, eval, feed, expect, source =
 | 
			
		||||
  helpers.execute, helpers.eq, helpers.clear, helpers.eval, helpers.feed,
 | 
			
		||||
local feed_command, eq, clear, eval, feed, expect, source =
 | 
			
		||||
  helpers.feed_command, helpers.eq, helpers.clear, helpers.eval, helpers.feed,
 | 
			
		||||
  helpers.expect, helpers.source
 | 
			
		||||
 | 
			
		||||
if helpers.pending_win32(pending) then return end
 | 
			
		||||
@@ -13,7 +13,7 @@ describe(':recover', function()
 | 
			
		||||
 | 
			
		||||
  it('fails if given a non-existent swapfile', function()
 | 
			
		||||
    local swapname = 'bogus-swapfile'
 | 
			
		||||
    execute('recover '..swapname) -- This should not segfault. #2117
 | 
			
		||||
    feed_command('recover '..swapname) -- This should not segfault. #2117
 | 
			
		||||
    eq('E305: No swap file found for '..swapname, eval('v:errmsg'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
@@ -40,12 +40,12 @@ describe(':preserve', function()
 | 
			
		||||
    ]]
 | 
			
		||||
 | 
			
		||||
    source(init)
 | 
			
		||||
    execute('set swapfile fileformat=unix undolevels=-1')
 | 
			
		||||
    feed_command('set swapfile fileformat=unix undolevels=-1')
 | 
			
		||||
    -- Put swapdir at the start of the 'directory' list. #1836
 | 
			
		||||
    execute('set directory^='..swapdir..'//')
 | 
			
		||||
    execute('edit '..testfile)
 | 
			
		||||
    feed_command('set directory^='..swapdir..'//')
 | 
			
		||||
    feed_command('edit '..testfile)
 | 
			
		||||
    feed('isometext<esc>')
 | 
			
		||||
    execute('preserve')
 | 
			
		||||
    feed_command('preserve')
 | 
			
		||||
    source('redir => g:swapname | swapname | redir END')
 | 
			
		||||
 | 
			
		||||
    local swappath1 = eval('g:swapname')
 | 
			
		||||
@@ -59,8 +59,8 @@ describe(':preserve', function()
 | 
			
		||||
    source(init)
 | 
			
		||||
 | 
			
		||||
    -- Use the "SwapExists" event to choose the (R)ecover choice at the dialog.
 | 
			
		||||
    execute('autocmd SwapExists * let v:swapchoice = "r"')
 | 
			
		||||
    execute('silent edit '..testfile)
 | 
			
		||||
    feed_command('autocmd SwapExists * let v:swapchoice = "r"')
 | 
			
		||||
    feed_command('silent edit '..testfile)
 | 
			
		||||
    source('redir => g:swapname | swapname | redir END')
 | 
			
		||||
 | 
			
		||||
    local swappath2 = eval('g:swapname')
 | 
			
		||||
 
 | 
			
		||||
@@ -5,7 +5,7 @@ local clear = helpers.clear
 | 
			
		||||
local insert = helpers.insert
 | 
			
		||||
local feed = helpers.feed
 | 
			
		||||
local expect = helpers.expect
 | 
			
		||||
local execute = helpers.execute
 | 
			
		||||
local feed_command = helpers.feed_command
 | 
			
		||||
local exc_exec = helpers.exc_exec
 | 
			
		||||
 | 
			
		||||
describe(':undojoin command', function()
 | 
			
		||||
@@ -14,10 +14,10 @@ describe(':undojoin command', function()
 | 
			
		||||
    insert([[
 | 
			
		||||
    Line of text 1
 | 
			
		||||
    Line of text 2]])
 | 
			
		||||
    execute('goto 1')
 | 
			
		||||
    feed_command('goto 1')
 | 
			
		||||
  end)
 | 
			
		||||
  it('joins changes in a buffer', function()
 | 
			
		||||
    execute('undojoin | delete')
 | 
			
		||||
    feed_command('undojoin | delete')
 | 
			
		||||
    expect([[
 | 
			
		||||
    Line of text 2]])
 | 
			
		||||
    feed('u')
 | 
			
		||||
@@ -26,7 +26,7 @@ describe(':undojoin command', function()
 | 
			
		||||
  end)
 | 
			
		||||
  it('does not corrupt undolist when connected with redo', function()
 | 
			
		||||
    feed('ixx<esc>')
 | 
			
		||||
    execute('undojoin | redo')
 | 
			
		||||
    feed_command('undojoin | redo')
 | 
			
		||||
    expect([[
 | 
			
		||||
    xxLine of text 1
 | 
			
		||||
    Line of text 2]])
 | 
			
		||||
 
 | 
			
		||||
@@ -1,11 +1,12 @@
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local lfs = require('lfs')
 | 
			
		||||
local eq, eval, clear, write_file, execute, source, insert =
 | 
			
		||||
local eq, eval, clear, write_file, command, source, insert =
 | 
			
		||||
  helpers.eq, helpers.eval, helpers.clear, helpers.write_file,
 | 
			
		||||
  helpers.execute, helpers.source, helpers.insert
 | 
			
		||||
  helpers.command, helpers.source, helpers.insert
 | 
			
		||||
local redir_exec = helpers.redir_exec
 | 
			
		||||
local exc_exec = helpers.exc_exec
 | 
			
		||||
local command = helpers.command
 | 
			
		||||
local feed_command = helpers.feed_command
 | 
			
		||||
local funcs = helpers.funcs
 | 
			
		||||
local meths = helpers.meths
 | 
			
		||||
 | 
			
		||||
@@ -33,9 +34,9 @@ describe(':write', function()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('&backupcopy=auto preserves symlinks', function()
 | 
			
		||||
    execute('set backupcopy=auto')
 | 
			
		||||
    command('set backupcopy=auto')
 | 
			
		||||
    write_file('test_bkc_file.txt', 'content0')
 | 
			
		||||
    execute("silent !ln -s test_bkc_file.txt test_bkc_link.txt")
 | 
			
		||||
    command("silent !ln -s test_bkc_file.txt test_bkc_link.txt")
 | 
			
		||||
    source([[
 | 
			
		||||
      edit test_bkc_link.txt
 | 
			
		||||
      call setline(1, ['content1'])
 | 
			
		||||
@@ -46,9 +47,9 @@ describe(':write', function()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('&backupcopy=no replaces symlink with new file', function()
 | 
			
		||||
    execute('set backupcopy=no')
 | 
			
		||||
    command('set backupcopy=no')
 | 
			
		||||
    write_file('test_bkc_file.txt', 'content0')
 | 
			
		||||
    execute("silent !ln -s test_bkc_file.txt test_bkc_link.txt")
 | 
			
		||||
    command("silent !ln -s test_bkc_file.txt test_bkc_link.txt")
 | 
			
		||||
    source([[
 | 
			
		||||
      edit test_bkc_link.txt
 | 
			
		||||
      call setline(1, ['content1'])
 | 
			
		||||
@@ -69,7 +70,7 @@ describe(':write', function()
 | 
			
		||||
    insert(text)
 | 
			
		||||
 | 
			
		||||
    -- Blocks until a consumer reads the FIFO.
 | 
			
		||||
    execute("write >> test_fifo")
 | 
			
		||||
    feed_command("write >> test_fifo")
 | 
			
		||||
 | 
			
		||||
    -- Read the FIFO, this will unblock the :write above.
 | 
			
		||||
    local fifo = assert(io.open("test_fifo"))
 | 
			
		||||
 
 | 
			
		||||
@@ -1,20 +1,21 @@
 | 
			
		||||
-- Specs for :wundo and underlying functions
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local execute, clear, eval, feed, spawn, nvim_prog, set_session =
 | 
			
		||||
  helpers.execute, helpers.clear, helpers.eval, helpers.feed, helpers.spawn,
 | 
			
		||||
local command, clear, eval, spawn, nvim_prog, set_session =
 | 
			
		||||
  helpers.command, helpers.clear, helpers.eval, helpers.spawn,
 | 
			
		||||
  helpers.nvim_prog, helpers.set_session
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
describe(':wundo', function()
 | 
			
		||||
  before_each(clear)
 | 
			
		||||
  after_each(function()
 | 
			
		||||
    os.remove(eval('getcwd()') .. '/foo')
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('safely fails on new, non-empty buffer', function()
 | 
			
		||||
    feed('iabc<esc>')
 | 
			
		||||
    execute('wundo foo') -- This should not segfault. #1027
 | 
			
		||||
    command('normal! iabc')
 | 
			
		||||
    command('wundo foo') -- This should not segfault. #1027
 | 
			
		||||
    --TODO: check messages for error message
 | 
			
		||||
 | 
			
		||||
    os.remove(eval('getcwd()') .. '/foo') --cleanup
 | 
			
		||||
  end)
 | 
			
		||||
end)
 | 
			
		||||
 | 
			
		||||
@@ -23,7 +24,7 @@ describe('u_* functions', function()
 | 
			
		||||
    local session = spawn({nvim_prog, '-u', 'NONE', '-i', 'NONE', '--embed',
 | 
			
		||||
                           '-c', 'set undodir=. undofile'})
 | 
			
		||||
    set_session(session)
 | 
			
		||||
    execute('echo "True"')  -- Should not error out due to crashed Neovim
 | 
			
		||||
    command('echo "True"')  -- Should not error out due to crashed Neovim
 | 
			
		||||
    session:close()
 | 
			
		||||
  end)
 | 
			
		||||
end)
 | 
			
		||||
 
 | 
			
		||||
@@ -1,8 +1,8 @@
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local lfs = require('lfs')
 | 
			
		||||
local execute, eq, neq, spawn, nvim_prog, set_session, wait, write_file
 | 
			
		||||
  = helpers.execute, helpers.eq, helpers.neq, helpers.spawn,
 | 
			
		||||
  helpers.nvim_prog, helpers.set_session, helpers.wait, helpers.write_file
 | 
			
		||||
local command, eq, neq, spawn, nvim_prog, set_session, write_file =
 | 
			
		||||
  helpers.command, helpers.eq, helpers.neq, helpers.spawn,
 | 
			
		||||
  helpers.nvim_prog, helpers.set_session, helpers.write_file
 | 
			
		||||
 | 
			
		||||
describe(':wshada', function()
 | 
			
		||||
  local shada_file = 'wshada_test'
 | 
			
		||||
@@ -24,8 +24,7 @@ describe(':wshada', function()
 | 
			
		||||
  it('creates a shada file', function()
 | 
			
		||||
    -- file should _not_ exist
 | 
			
		||||
    eq(nil, lfs.attributes(shada_file))
 | 
			
		||||
    execute('wsh! '..shada_file)
 | 
			
		||||
    wait()
 | 
			
		||||
    command('wsh! '..shada_file)
 | 
			
		||||
    -- file _should_ exist
 | 
			
		||||
    neq(nil, lfs.attributes(shada_file))
 | 
			
		||||
  end)
 | 
			
		||||
@@ -40,8 +39,7 @@ describe(':wshada', function()
 | 
			
		||||
    eq(text, io.open(shada_file):read())
 | 
			
		||||
    neq(nil, lfs.attributes(shada_file))
 | 
			
		||||
 | 
			
		||||
    execute('wsh! '..shada_file)
 | 
			
		||||
    wait()
 | 
			
		||||
    command('wsh! '..shada_file)
 | 
			
		||||
 | 
			
		||||
    -- File should have been overwritten with a shada file.
 | 
			
		||||
    local fp = io.open(shada_file, 'r')
 | 
			
		||||
 
 | 
			
		||||
@@ -566,7 +566,6 @@ local M = {
 | 
			
		||||
  iswin = iswin,
 | 
			
		||||
  feed = feed,
 | 
			
		||||
  feed_command = feed_command,
 | 
			
		||||
  execute = feed_command,  -- FIXME Remove
 | 
			
		||||
  eval = nvim_eval,
 | 
			
		||||
  call = nvim_call,
 | 
			
		||||
  command = nvim_command,
 | 
			
		||||
 
 | 
			
		||||
@@ -3,7 +3,7 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear, feed, insert = helpers.clear, helpers.feed, helpers.insert
 | 
			
		||||
local execute, expect = helpers.execute, helpers.expect
 | 
			
		||||
local feed_command, expect = helpers.feed_command, helpers.expect
 | 
			
		||||
 | 
			
		||||
describe('filename recognition', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
@@ -17,17 +17,17 @@ describe('filename recognition', function()
 | 
			
		||||
      fourth test for URL:\\machine.name\tmp\vimtest2d, and other text]])
 | 
			
		||||
 | 
			
		||||
    -- Go to the first URL and append it to the beginning
 | 
			
		||||
    execute('/^first', '/tmp', 'call append(0, expand("<cfile>"))')
 | 
			
		||||
    feed_command('/^first', '/tmp', 'call append(0, expand("<cfile>"))')
 | 
			
		||||
 | 
			
		||||
    -- Repeat for the second URL
 | 
			
		||||
    -- this time, navigate to the word "URL" instead of "tmp"
 | 
			
		||||
    execute('/^second', '/URL', 'call append(1, expand("<cfile>"))')
 | 
			
		||||
    feed_command('/^second', '/URL', 'call append(1, expand("<cfile>"))')
 | 
			
		||||
 | 
			
		||||
    -- Repeat for the remaining URLs. This time, the 'isfname' option must be
 | 
			
		||||
    -- set to allow '\' in filenames
 | 
			
		||||
    execute('set isf=@,48-57,/,.,-,_,+,,,$,:,~,\\')
 | 
			
		||||
    execute('/^third', '/name', 'call append(2, expand("<cfile>"))')
 | 
			
		||||
    execute('/^fourth', '/URL', 'call append(3, expand("<cfile>"))')
 | 
			
		||||
    feed_command('set isf=@,48-57,/,.,-,_,+,,,$,:,~,\\')
 | 
			
		||||
    feed_command('/^third', '/name', 'call append(2, expand("<cfile>"))')
 | 
			
		||||
    feed_command('/^fourth', '/URL', 'call append(3, expand("<cfile>"))')
 | 
			
		||||
 | 
			
		||||
    -- Delete the initial text, which now starts at line 5
 | 
			
		||||
    feed('5GdG')
 | 
			
		||||
 
 | 
			
		||||
@@ -1,10 +1,9 @@
 | 
			
		||||
-- vim: set foldmethod=marker foldmarker=[[,]] :
 | 
			
		||||
-- Test for autocommand that changes current buffer on BufEnter event.
 | 
			
		||||
-- Check if modelines are interpreted for the correct buffer.
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear, feed, insert = helpers.clear, helpers.feed, helpers.insert
 | 
			
		||||
local execute, expect = helpers.execute, helpers.expect
 | 
			
		||||
local feed_command, expect = helpers.feed_command, helpers.expect
 | 
			
		||||
 | 
			
		||||
describe('BufEnter with modelines', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
@@ -20,34 +19,34 @@ describe('BufEnter with modelines', function()
 | 
			
		||||
          this is a test
 | 
			
		||||
      end of test file Xxx]])
 | 
			
		||||
 | 
			
		||||
    execute('au BufEnter Xxx brew')
 | 
			
		||||
    feed_command('au BufEnter Xxx brew')
 | 
			
		||||
 | 
			
		||||
    -- Write test file Xxx
 | 
			
		||||
    execute('/start of')
 | 
			
		||||
    execute('.,/end of/w! Xxx')
 | 
			
		||||
    execute('set ai modeline modelines=3')
 | 
			
		||||
    feed_command('/start of')
 | 
			
		||||
    feed_command('.,/end of/w! Xxx')
 | 
			
		||||
    feed_command('set ai modeline modelines=3')
 | 
			
		||||
 | 
			
		||||
    -- Split to Xxx, autocmd will do :brew
 | 
			
		||||
    execute('sp Xxx')
 | 
			
		||||
    feed_command('sp Xxx')
 | 
			
		||||
 | 
			
		||||
    -- Append text with autoindent to this file
 | 
			
		||||
    feed('G?this is a<CR>')
 | 
			
		||||
    feed('othis should be auto-indented<Esc>')
 | 
			
		||||
 | 
			
		||||
    -- Go to Xxx, no autocmd anymore
 | 
			
		||||
    execute('au! BufEnter Xxx')
 | 
			
		||||
    execute('buf Xxx')
 | 
			
		||||
    feed_command('au! BufEnter Xxx')
 | 
			
		||||
    feed_command('buf Xxx')
 | 
			
		||||
 | 
			
		||||
    -- Append text without autoindent to Xxx
 | 
			
		||||
    feed('G?this is a<CR>')
 | 
			
		||||
    feed('othis should be in column 1<Esc>')
 | 
			
		||||
    execute('wq')
 | 
			
		||||
    feed_command('wq')
 | 
			
		||||
 | 
			
		||||
    -- Include Xxx in the current file
 | 
			
		||||
    feed('G:r Xxx<CR>')
 | 
			
		||||
 | 
			
		||||
    -- Vim issue #57 do not move cursor on <c-o> when autoindent is set
 | 
			
		||||
    execute('set fo+=r')
 | 
			
		||||
    feed_command('set fo+=r')
 | 
			
		||||
    feed('G')
 | 
			
		||||
    feed('o# abcdef<Esc>2hi<CR><c-o>d0<Esc>')
 | 
			
		||||
    feed('o# abcdef<Esc>2hi<c-o>d0<Esc>')
 | 
			
		||||
 
 | 
			
		||||
@@ -3,7 +3,8 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear, feed, insert = helpers.clear, helpers.feed, helpers.insert
 | 
			
		||||
local execute, expect = helpers.execute, helpers.expect
 | 
			
		||||
local command, expect = helpers.command, helpers.expect
 | 
			
		||||
local wait = helpers.wait
 | 
			
		||||
 | 
			
		||||
describe('test5', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
@@ -18,35 +19,37 @@ describe('test5', function()
 | 
			
		||||
      	this is a test
 | 
			
		||||
      end of test file Xxx]])
 | 
			
		||||
 | 
			
		||||
    execute('w! Xxx0')
 | 
			
		||||
    execute('au BufLeave Xxx bwipe')
 | 
			
		||||
    execute('/start of')
 | 
			
		||||
    command('w! Xxx0')
 | 
			
		||||
    command('au BufLeave Xxx bwipe')
 | 
			
		||||
    command('/start of')
 | 
			
		||||
 | 
			
		||||
    -- Write test file Xxx.
 | 
			
		||||
    execute('.,/end of/w! Xxx')
 | 
			
		||||
    command('.,/end of/w! Xxx')
 | 
			
		||||
 | 
			
		||||
    -- Split to Xxx.
 | 
			
		||||
    execute('sp Xxx')
 | 
			
		||||
    command('sp Xxx')
 | 
			
		||||
 | 
			
		||||
    -- Delete buffer Xxx, now we're back here.
 | 
			
		||||
    execute('bwipe')
 | 
			
		||||
    command('bwipe')
 | 
			
		||||
    feed('G?this is a<cr>')
 | 
			
		||||
    feed('othis is some more text<esc>')
 | 
			
		||||
    wait()
 | 
			
		||||
 | 
			
		||||
    -- Append some text to this file.
 | 
			
		||||
 | 
			
		||||
    -- Write current file contents.
 | 
			
		||||
    execute('?start?,$yank A')
 | 
			
		||||
    command('?start?,$yank A')
 | 
			
		||||
 | 
			
		||||
    -- Delete current buffer, get an empty one.
 | 
			
		||||
    execute('bwipe!')
 | 
			
		||||
    command('bwipe!')
 | 
			
		||||
    -- Append an extra line to the output register.
 | 
			
		||||
    feed('ithis is another test line<esc>:yank A<cr>')
 | 
			
		||||
    wait()
 | 
			
		||||
 | 
			
		||||
    -- Output results
 | 
			
		||||
    execute('%d')
 | 
			
		||||
    execute('0put a')
 | 
			
		||||
    execute('$d')
 | 
			
		||||
    command('%d')
 | 
			
		||||
    command('0put a')
 | 
			
		||||
    command('$d')
 | 
			
		||||
 | 
			
		||||
    -- Assert buffer contents.
 | 
			
		||||
    expect([[
 | 
			
		||||
 
 | 
			
		||||
@@ -2,8 +2,9 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear, feed, insert = helpers.clear, helpers.feed, helpers.insert
 | 
			
		||||
local execute, dedent, eq = helpers.execute, helpers.dedent, helpers.eq
 | 
			
		||||
local command, dedent, eq = helpers.command, helpers.dedent, helpers.eq
 | 
			
		||||
local curbuf_contents = helpers.curbuf_contents
 | 
			
		||||
local wait = helpers.wait
 | 
			
		||||
 | 
			
		||||
describe('argument list', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
@@ -16,9 +17,10 @@ describe('argument list', function()
 | 
			
		||||
          this is a test
 | 
			
		||||
          this is a test
 | 
			
		||||
      end of test file Xxx]])
 | 
			
		||||
    wait()
 | 
			
		||||
 | 
			
		||||
    execute('au BufReadPost Xxx2 next Xxx2 Xxx1')
 | 
			
		||||
    execute('/^start of')
 | 
			
		||||
    command('au BufReadPost Xxx2 next Xxx2 Xxx1')
 | 
			
		||||
    command('/^start of')
 | 
			
		||||
 | 
			
		||||
    -- Write test file Xxx1
 | 
			
		||||
    feed('A1<Esc>:.,/end of/w! Xxx1<cr>')
 | 
			
		||||
@@ -28,29 +30,31 @@ describe('argument list', function()
 | 
			
		||||
 | 
			
		||||
    -- Write test file Xxx3
 | 
			
		||||
    feed('$r3:.,/end of/w! Xxx3<cr>')
 | 
			
		||||
    wait()
 | 
			
		||||
 | 
			
		||||
    -- Redefine arglist; go to Xxx1
 | 
			
		||||
    execute('next! Xxx1 Xxx2 Xxx3')
 | 
			
		||||
    command('next! Xxx1 Xxx2 Xxx3')
 | 
			
		||||
 | 
			
		||||
    -- Open window for all args
 | 
			
		||||
    execute('all')
 | 
			
		||||
    command('all')
 | 
			
		||||
 | 
			
		||||
    -- Write contents of Xxx1
 | 
			
		||||
    execute('%yank A')
 | 
			
		||||
    command('%yank A')
 | 
			
		||||
 | 
			
		||||
    -- Append contents of last window (Xxx1)
 | 
			
		||||
    feed('')
 | 
			
		||||
    execute('%yank A')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('%yank A')
 | 
			
		||||
 | 
			
		||||
    -- should now be in Xxx2
 | 
			
		||||
    execute('rew')
 | 
			
		||||
    command('rew')
 | 
			
		||||
 | 
			
		||||
    -- Append contents of Xxx2
 | 
			
		||||
    execute('%yank A')
 | 
			
		||||
    command('%yank A')
 | 
			
		||||
 | 
			
		||||
    execute('%d')
 | 
			
		||||
    execute('0put=@a')
 | 
			
		||||
    execute('$d')
 | 
			
		||||
    command('%d')
 | 
			
		||||
    command('0put=@a')
 | 
			
		||||
    command('$d')
 | 
			
		||||
 | 
			
		||||
    eq(dedent([[
 | 
			
		||||
      start of test file Xxx1
 | 
			
		||||
 
 | 
			
		||||
@@ -2,7 +2,7 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear, feed, insert = helpers.clear, helpers.feed, helpers.insert
 | 
			
		||||
local execute, expect = helpers.execute, helpers.expect
 | 
			
		||||
local feed_command, expect = helpers.feed_command, helpers.expect
 | 
			
		||||
 | 
			
		||||
describe(':ball', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
@@ -14,44 +14,44 @@ describe(':ball', function()
 | 
			
		||||
          this is a test
 | 
			
		||||
      end of test file Xxx]])
 | 
			
		||||
 | 
			
		||||
    execute('w! Xxx0')
 | 
			
		||||
    feed_command('w! Xxx0')
 | 
			
		||||
    feed('gg')
 | 
			
		||||
 | 
			
		||||
    -- Write test file Xxx1
 | 
			
		||||
    feed('A1:.,/end of/w! Xxx1<cr>')
 | 
			
		||||
    execute('sp Xxx1')
 | 
			
		||||
    execute('close')
 | 
			
		||||
    feed_command('sp Xxx1')
 | 
			
		||||
    feed_command('close')
 | 
			
		||||
 | 
			
		||||
    -- Write test file Xxx2
 | 
			
		||||
    feed('$r2:.,/end of/w! Xxx2<cr>')
 | 
			
		||||
    execute('sp Xxx2')
 | 
			
		||||
    execute('close')
 | 
			
		||||
    feed_command('sp Xxx2')
 | 
			
		||||
    feed_command('close')
 | 
			
		||||
 | 
			
		||||
    -- Write test file Xxx3
 | 
			
		||||
    feed('$r3:.,/end of/w! Xxx3<cr>')
 | 
			
		||||
    execute('sp Xxx3')
 | 
			
		||||
    execute('close')
 | 
			
		||||
    feed_command('sp Xxx3')
 | 
			
		||||
    feed_command('close')
 | 
			
		||||
 | 
			
		||||
    execute('au BufReadPost Xxx2 bwipe')
 | 
			
		||||
    feed_command('au BufReadPost Xxx2 bwipe')
 | 
			
		||||
 | 
			
		||||
    -- Open window for all args, close Xxx2
 | 
			
		||||
    feed('$r4:ball<cr>')
 | 
			
		||||
   
 | 
			
		||||
    -- Write contents of this file
 | 
			
		||||
    execute('%yank A')
 | 
			
		||||
    feed_command('%yank A')
 | 
			
		||||
    
 | 
			
		||||
    -- Append contents of second window (Xxx1)
 | 
			
		||||
    feed('')
 | 
			
		||||
    execute('%yank A')
 | 
			
		||||
    feed_command('%yank A')
 | 
			
		||||
 | 
			
		||||
    -- Append contents of last window (this file)
 | 
			
		||||
    feed('')
 | 
			
		||||
    execute('%yank A')
 | 
			
		||||
    feed_command('%yank A')
 | 
			
		||||
 | 
			
		||||
    execute('bf')
 | 
			
		||||
    execute('%d')
 | 
			
		||||
    execute('0put=@a')
 | 
			
		||||
    execute('$d')
 | 
			
		||||
    feed_command('bf')
 | 
			
		||||
    feed_command('%d')
 | 
			
		||||
    feed_command('0put=@a')
 | 
			
		||||
    feed_command('$d')
 | 
			
		||||
 | 
			
		||||
    expect([[
 | 
			
		||||
      start of test file Xxx4
 | 
			
		||||
 
 | 
			
		||||
@@ -3,7 +3,7 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local feed, source = helpers.feed, helpers.source
 | 
			
		||||
local clear, execute, expect, eq, eval = helpers.clear, helpers.execute, helpers.expect, helpers.eq, helpers.eval
 | 
			
		||||
local clear, feed_command, expect, eq, eval = helpers.clear, helpers.feed_command, helpers.expect, helpers.eq, helpers.eval
 | 
			
		||||
local write_file, wait, dedent = helpers.write_file, helpers.wait, helpers.dedent
 | 
			
		||||
local io = require('io')
 | 
			
		||||
 | 
			
		||||
@@ -25,15 +25,15 @@ describe('autocommands that delete and unload buffers:', function()
 | 
			
		||||
  before_each(clear)
 | 
			
		||||
 | 
			
		||||
  it('BufWritePre, BufUnload', function()
 | 
			
		||||
    execute('au BufWritePre Xxx1 bunload')
 | 
			
		||||
    execute('au BufWritePre Xxx2 bwipe')
 | 
			
		||||
    execute('e Xxx2')
 | 
			
		||||
    feed_command('au BufWritePre Xxx1 bunload')
 | 
			
		||||
    feed_command('au BufWritePre Xxx2 bwipe')
 | 
			
		||||
    feed_command('e Xxx2')
 | 
			
		||||
    eq('Xxx2', eval('bufname("%")'))
 | 
			
		||||
    execute('e Xxx1')
 | 
			
		||||
    feed_command('e Xxx1')
 | 
			
		||||
    eq('Xxx1', eval('bufname("%")'))
 | 
			
		||||
    -- The legacy test file did not check the error message.
 | 
			
		||||
    execute('let v:errmsg = "no error"')
 | 
			
		||||
    execute('write')
 | 
			
		||||
    feed_command('let v:errmsg = "no error"')
 | 
			
		||||
    feed_command('write')
 | 
			
		||||
    -- Discard all "hit enter" prompts and messages.
 | 
			
		||||
    feed('<C-L>')
 | 
			
		||||
    eq('E203: Autocommands deleted or unloaded buffer to be written',
 | 
			
		||||
@@ -41,11 +41,11 @@ describe('autocommands that delete and unload buffers:', function()
 | 
			
		||||
    eq('Xxx2', eval('bufname("%")'))
 | 
			
		||||
    expect(text2)
 | 
			
		||||
    -- Start editing Xxx2.
 | 
			
		||||
    execute('e! Xxx2')
 | 
			
		||||
    feed_command('e! Xxx2')
 | 
			
		||||
    -- The legacy test file did not check the error message.
 | 
			
		||||
    execute('let v:errmsg = "no error"')
 | 
			
		||||
    feed_command('let v:errmsg = "no error"')
 | 
			
		||||
    -- Write Xxx2, will delete the buffer and give an error msg.
 | 
			
		||||
    execute('w')
 | 
			
		||||
    feed_command('w')
 | 
			
		||||
    -- Discard all "hit enter" prompts and messages.
 | 
			
		||||
    feed('<C-L>')
 | 
			
		||||
    eq('E203: Autocommands deleted or unloaded buffer to be written',
 | 
			
		||||
@@ -73,17 +73,17 @@ describe('autocommands that delete and unload buffers:', function()
 | 
			
		||||
      au BufUnload * call CloseAll()
 | 
			
		||||
      au VimLeave * call WriteToOut()
 | 
			
		||||
    ]])
 | 
			
		||||
    execute('e Xxx2')
 | 
			
		||||
    feed_command('e Xxx2')
 | 
			
		||||
    -- Discard all "hit enter" prompts and messages.
 | 
			
		||||
    feed('<C-L>')
 | 
			
		||||
    execute('e Xxx1')
 | 
			
		||||
    feed_command('e Xxx1')
 | 
			
		||||
    -- Discard all "hit enter" prompts and messages.
 | 
			
		||||
    feed('<C-L>')
 | 
			
		||||
    execute('e Makefile') -- an existing file
 | 
			
		||||
    feed_command('e Makefile') -- an existing file
 | 
			
		||||
    feed('<C-L>')
 | 
			
		||||
    execute('sp new2')
 | 
			
		||||
    feed_command('sp new2')
 | 
			
		||||
    feed('<C-L>')
 | 
			
		||||
    execute('q')
 | 
			
		||||
    feed_command('q')
 | 
			
		||||
    wait()
 | 
			
		||||
    eq('VimLeave done',
 | 
			
		||||
       string.match(io.open('test.out', 'r'):read('*all'), "^%s*(.-)%s*$"))
 | 
			
		||||
 
 | 
			
		||||
@@ -14,8 +14,8 @@
 | 
			
		||||
 | 
			
		||||
local helpers= require('test.functional.helpers')(after_each)
 | 
			
		||||
local lfs = require('lfs')
 | 
			
		||||
local clear, execute, expect, eq, neq, dedent, write_file, feed =
 | 
			
		||||
  helpers.clear, helpers.execute, helpers.expect, helpers.eq, helpers.neq,
 | 
			
		||||
local clear, feed_command, expect, eq, neq, dedent, write_file, feed =
 | 
			
		||||
  helpers.clear, helpers.feed_command, helpers.expect, helpers.eq, helpers.neq,
 | 
			
		||||
  helpers.dedent, helpers.write_file, helpers.feed
 | 
			
		||||
 | 
			
		||||
if helpers.pending_win32(pending) then return end
 | 
			
		||||
@@ -66,26 +66,26 @@ describe('file reading, writing and bufnew and filter autocommands', function()
 | 
			
		||||
 | 
			
		||||
    it('FileReadPost (using gzip)', function()
 | 
			
		||||
      prepare_gz_file('Xtestfile', text1)
 | 
			
		||||
      execute('let $GZIP = ""')
 | 
			
		||||
      feed_command('let $GZIP = ""')
 | 
			
		||||
      --execute('au FileChangedShell * echo "caught FileChangedShell"')
 | 
			
		||||
      execute('set bin')
 | 
			
		||||
      execute("au FileReadPost    *.gz   '[,']!gzip -d")
 | 
			
		||||
      feed_command('set bin')
 | 
			
		||||
      feed_command("au FileReadPost    *.gz   '[,']!gzip -d")
 | 
			
		||||
      -- Read and decompress the testfile.
 | 
			
		||||
      execute('$r Xtestfile.gz')
 | 
			
		||||
      feed_command('$r Xtestfile.gz')
 | 
			
		||||
      expect('\n'..text1)
 | 
			
		||||
    end)
 | 
			
		||||
 | 
			
		||||
    it('BufReadPre, BufReadPost (using gzip)', function()
 | 
			
		||||
      prepare_gz_file('Xtestfile', text1)
 | 
			
		||||
      local gzip_data = io.open('Xtestfile.gz'):read('*all')
 | 
			
		||||
      execute('let $GZIP = ""')
 | 
			
		||||
      feed_command('let $GZIP = ""')
 | 
			
		||||
      -- Setup autocommands to decompress before reading and re-compress afterwards.
 | 
			
		||||
      execute("au BufReadPre   *.gz  exe '!gzip -d ' . shellescape(expand('<afile>'))")
 | 
			
		||||
      execute("au BufReadPre   *.gz  call rename(expand('<afile>:r'), expand('<afile>'))")
 | 
			
		||||
      execute("au BufReadPost  *.gz  call rename(expand('<afile>'), expand('<afile>:r'))")
 | 
			
		||||
      execute("au BufReadPost  *.gz  exe '!gzip ' . shellescape(expand('<afile>:r'))")
 | 
			
		||||
      feed_command("au BufReadPre   *.gz  exe '!gzip -d ' . shellescape(expand('<afile>'))")
 | 
			
		||||
      feed_command("au BufReadPre   *.gz  call rename(expand('<afile>:r'), expand('<afile>'))")
 | 
			
		||||
      feed_command("au BufReadPost  *.gz  call rename(expand('<afile>'), expand('<afile>:r'))")
 | 
			
		||||
      feed_command("au BufReadPost  *.gz  exe '!gzip ' . shellescape(expand('<afile>:r'))")
 | 
			
		||||
      -- Edit compressed file.
 | 
			
		||||
      execute('e! Xtestfile.gz')
 | 
			
		||||
      feed_command('e! Xtestfile.gz')
 | 
			
		||||
      -- Discard all prompts and messages.
 | 
			
		||||
      feed('<C-L>')
 | 
			
		||||
      -- Expect the decompressed file in the buffer.
 | 
			
		||||
@@ -96,11 +96,11 @@ describe('file reading, writing and bufnew and filter autocommands', function()
 | 
			
		||||
 | 
			
		||||
    it('FileReadPre, FileReadPost', function()
 | 
			
		||||
      prepare_gz_file('Xtestfile', text1)
 | 
			
		||||
      execute('au! FileReadPre    *.gz   exe "silent !gzip -d " . shellescape(expand("<afile>"))')
 | 
			
		||||
      execute('au  FileReadPre    *.gz   call rename(expand("<afile>:r"), expand("<afile>"))')
 | 
			
		||||
      execute("au! FileReadPost   *.gz   '[,']s/l/L/")
 | 
			
		||||
      feed_command('au! FileReadPre    *.gz   exe "silent !gzip -d " . shellescape(expand("<afile>"))')
 | 
			
		||||
      feed_command('au  FileReadPre    *.gz   call rename(expand("<afile>:r"), expand("<afile>"))')
 | 
			
		||||
      feed_command("au! FileReadPost   *.gz   '[,']s/l/L/")
 | 
			
		||||
      -- Read compressed file.
 | 
			
		||||
      execute('$r Xtestfile.gz')
 | 
			
		||||
      feed_command('$r Xtestfile.gz')
 | 
			
		||||
      -- Discard all prompts and messages.
 | 
			
		||||
      feed('<C-L>')
 | 
			
		||||
      expect([[
 | 
			
		||||
@@ -121,17 +121,17 @@ describe('file reading, writing and bufnew and filter autocommands', function()
 | 
			
		||||
  end
 | 
			
		||||
 | 
			
		||||
  it('FileAppendPre, FileAppendPost', function()
 | 
			
		||||
    execute('au BufNewFile      *.c    read Xtest.c')
 | 
			
		||||
    feed_command('au BufNewFile      *.c    read Xtest.c')
 | 
			
		||||
    -- Will load Xtest.c.
 | 
			
		||||
    execute('e! foo.c')
 | 
			
		||||
    execute("au FileAppendPre   *.out  '[,']s/new/NEW/")
 | 
			
		||||
    execute('au FileAppendPost  *.out  !cat Xtest.c >>test.out')
 | 
			
		||||
    feed_command('e! foo.c')
 | 
			
		||||
    feed_command("au FileAppendPre   *.out  '[,']s/new/NEW/")
 | 
			
		||||
    feed_command('au FileAppendPost  *.out  !cat Xtest.c >>test.out')
 | 
			
		||||
    -- Append it to the output file.
 | 
			
		||||
    execute('w>>test.out')
 | 
			
		||||
    feed_command('w>>test.out')
 | 
			
		||||
    -- Discard all prompts and messages.
 | 
			
		||||
    feed('<C-L>')
 | 
			
		||||
    -- Expect the decompressed file in the buffer.
 | 
			
		||||
    execute('e test.out')
 | 
			
		||||
    feed_command('e test.out')
 | 
			
		||||
    expect([[
 | 
			
		||||
      
 | 
			
		||||
      /*
 | 
			
		||||
@@ -166,18 +166,18 @@ describe('file reading, writing and bufnew and filter autocommands', function()
 | 
			
		||||
       * Here is a new .c file
 | 
			
		||||
       */]]))
 | 
			
		||||
    -- Need temp files here.
 | 
			
		||||
    execute('set shelltemp')
 | 
			
		||||
    execute('au FilterReadPre   *.out  call rename(expand("<afile>"), expand("<afile>") . ".t")')
 | 
			
		||||
    execute('au FilterReadPre   *.out  exe "silent !sed s/e/E/ " . shellescape(expand("<afile>")) . ".t >" . shellescape(expand("<afile>"))')
 | 
			
		||||
    execute('au FilterReadPre   *.out  exe "silent !rm " . shellescape(expand("<afile>")) . ".t"')
 | 
			
		||||
    execute("au FilterReadPost  *.out  '[,']s/x/X/g")
 | 
			
		||||
    feed_command('set shelltemp')
 | 
			
		||||
    feed_command('au FilterReadPre   *.out  call rename(expand("<afile>"), expand("<afile>") . ".t")')
 | 
			
		||||
    feed_command('au FilterReadPre   *.out  exe "silent !sed s/e/E/ " . shellescape(expand("<afile>")) . ".t >" . shellescape(expand("<afile>"))')
 | 
			
		||||
    feed_command('au FilterReadPre   *.out  exe "silent !rm " . shellescape(expand("<afile>")) . ".t"')
 | 
			
		||||
    feed_command("au FilterReadPost  *.out  '[,']s/x/X/g")
 | 
			
		||||
    -- Edit the output file.
 | 
			
		||||
    execute('e! test.out')
 | 
			
		||||
    execute('23,$!cat')
 | 
			
		||||
    feed_command('e! test.out')
 | 
			
		||||
    feed_command('23,$!cat')
 | 
			
		||||
    -- Discard all prompts and messages.
 | 
			
		||||
    feed('<C-L>')
 | 
			
		||||
    -- Remove CR for when sed adds them.
 | 
			
		||||
    execute([[23,$s/\r$//]])
 | 
			
		||||
    feed_command([[23,$s/\r$//]])
 | 
			
		||||
    expect([[
 | 
			
		||||
      startstart
 | 
			
		||||
      start of testfile
 | 
			
		||||
 
 | 
			
		||||
@@ -4,7 +4,7 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local feed, insert = helpers.feed, helpers.insert
 | 
			
		||||
local clear, execute, expect = helpers.clear, helpers.execute, helpers.expect
 | 
			
		||||
local clear, feed_command, expect = helpers.clear, helpers.feed_command, helpers.expect
 | 
			
		||||
 | 
			
		||||
describe('alignment', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
@@ -124,21 +124,21 @@ describe('alignment', function()
 | 
			
		||||
      bb bb bb bb
 | 
			
		||||
      cc cc cc cc]])
 | 
			
		||||
 | 
			
		||||
    execute('set tw=65')
 | 
			
		||||
    feed_command('set tw=65')
 | 
			
		||||
 | 
			
		||||
    feed([[:/^\s*test for :left/,/^\s*test for :center/ left<cr>]])
 | 
			
		||||
    feed([[:/^\s*test for :center/,/^\s*test for :right/ center<cr>]])
 | 
			
		||||
    feed([[:/^\s*test for :right/,/^xxx/-1 right<cr>]])
 | 
			
		||||
 | 
			
		||||
    execute('set fo+=tcroql tw=72')
 | 
			
		||||
    feed_command('set fo+=tcroql tw=72')
 | 
			
		||||
 | 
			
		||||
    feed('/xxxxxxxx$<cr>')
 | 
			
		||||
    feed('0gq6kk<cr>')
 | 
			
		||||
 | 
			
		||||
    -- Undo/redo here to make the next undo only work on the following changes.
 | 
			
		||||
    feed('u<cr>')
 | 
			
		||||
    execute('map gg :.,.+2s/^/x/<CR>kk:set tw=3<CR>gqq')
 | 
			
		||||
    execute('/^aa')
 | 
			
		||||
    feed_command('map gg :.,.+2s/^/x/<CR>kk:set tw=3<CR>gqq')
 | 
			
		||||
    feed_command('/^aa')
 | 
			
		||||
    feed('ggu<cr>')
 | 
			
		||||
 | 
			
		||||
    -- Assert buffer contents.
 | 
			
		||||
 
 | 
			
		||||
@@ -3,7 +3,7 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local feed, insert = helpers.feed, helpers.insert
 | 
			
		||||
local clear, execute, expect = helpers.clear, helpers.execute, helpers.expect
 | 
			
		||||
local clear, feed_command, expect = helpers.clear, helpers.feed_command, helpers.expect
 | 
			
		||||
 | 
			
		||||
describe([[performing "r<Tab>" with 'smarttab' and 'expandtab' set/not set, and "dv_"]], function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
@@ -19,24 +19,24 @@ describe([[performing "r<Tab>" with 'smarttab' and 'expandtab' set/not set, and
 | 
			
		||||
      test text
 | 
			
		||||
        Second line beginning with whitespace]])
 | 
			
		||||
 | 
			
		||||
    execute('set smarttab expandtab ts=8 sw=4')
 | 
			
		||||
    feed_command('set smarttab expandtab ts=8 sw=4')
 | 
			
		||||
    -- Make sure that backspace works, no matter what termcap is used.
 | 
			
		||||
    execute('set t_kD=x7f t_kb=x08')
 | 
			
		||||
    feed_command('set t_kD=x7f t_kb=x08')
 | 
			
		||||
 | 
			
		||||
    execute('/some')
 | 
			
		||||
    feed_command('/some')
 | 
			
		||||
    feed('r	')
 | 
			
		||||
    execute('set noexpandtab')
 | 
			
		||||
    execute('/other')
 | 
			
		||||
    feed_command('set noexpandtab')
 | 
			
		||||
    feed_command('/other')
 | 
			
		||||
    feed('r	<cr>')
 | 
			
		||||
    -- Test replacing with Tabs and then backspacing to undo it.
 | 
			
		||||
    feed('0wR			<bs><bs><bs><esc><cr>')
 | 
			
		||||
    -- Test replacing with Tabs.
 | 
			
		||||
    feed('0wR			<esc><cr>')
 | 
			
		||||
    -- Test that copyindent works with expandtab set.
 | 
			
		||||
    execute('set expandtab smartindent copyindent ts=8 sw=8 sts=8')
 | 
			
		||||
    feed_command('set expandtab smartindent copyindent ts=8 sw=8 sts=8')
 | 
			
		||||
    feed('o{<cr>x<esc>')
 | 
			
		||||
    execute('set nosol')
 | 
			
		||||
    execute('/Second line/')
 | 
			
		||||
    feed_command('set nosol')
 | 
			
		||||
    feed_command('/Second line/')
 | 
			
		||||
    -- Test "dv_"
 | 
			
		||||
    feed('fwdv_')
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
@@ -1,11 +1,10 @@
 | 
			
		||||
-- vim: set foldmethod=marker foldmarker=[[,]] :
 | 
			
		||||
-- Tests Blockwise Visual when there are TABs before the text.
 | 
			
		||||
-- First test for undo working properly when executing commands from a register.
 | 
			
		||||
-- Also test this in an empty buffer.
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear, feed, insert = helpers.clear, helpers.feed, helpers.insert
 | 
			
		||||
local execute, expect = helpers.execute, helpers.expect
 | 
			
		||||
local feed_command, expect = helpers.feed_command, helpers.expect
 | 
			
		||||
 | 
			
		||||
describe('blockwise visual', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
@@ -26,15 +25,15 @@ Ox jAy kdd]])
 | 
			
		||||
 | 
			
		||||
    feed(":let @a = 'Ox<C-v><Esc>jAy<C-v><Esc>kdd'<cr>")
 | 
			
		||||
    feed('G0k@au')
 | 
			
		||||
    execute('new')
 | 
			
		||||
    feed_command('new')
 | 
			
		||||
    feed('@auY')
 | 
			
		||||
    execute('quit')
 | 
			
		||||
    feed_command('quit')
 | 
			
		||||
    feed('GP')
 | 
			
		||||
    execute('/start here')
 | 
			
		||||
    feed_command('/start here')
 | 
			
		||||
    feed('"by$<C-v>jjlld')
 | 
			
		||||
    execute('/456')
 | 
			
		||||
    feed_command('/456')
 | 
			
		||||
    feed('<C-v>jj"bP')
 | 
			
		||||
    execute('$-3,$d')
 | 
			
		||||
    feed_command('$-3,$d')
 | 
			
		||||
 | 
			
		||||
    expect([[
 | 
			
		||||
123start here56
 | 
			
		||||
 
 | 
			
		||||
@@ -1,9 +1,8 @@
 | 
			
		||||
-- vim: set foldmethod=marker foldmarker=[[,]] :
 | 
			
		||||
-- Tests for [ CTRL-I with a count and CTRL-W CTRL-I with a count
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear, feed, insert = helpers.clear, helpers.feed, helpers.insert
 | 
			
		||||
local execute, expect = helpers.execute, helpers.expect
 | 
			
		||||
local feed_command, expect = helpers.feed_command, helpers.expect
 | 
			
		||||
 | 
			
		||||
describe('CTRL-W CTRL-I', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
@@ -20,18 +19,18 @@ describe('CTRL-W CTRL-I', function()
 | 
			
		||||
      test text]])
 | 
			
		||||
 | 
			
		||||
    -- Search for the second occurence of start and append to register
 | 
			
		||||
    execute('/start')
 | 
			
		||||
    feed_command('/start')
 | 
			
		||||
    feed('2[<C-i>')
 | 
			
		||||
    execute('yank A')
 | 
			
		||||
    feed_command('yank A')
 | 
			
		||||
 | 
			
		||||
    -- Same as above but using different keystrokes.
 | 
			
		||||
    feed('?start<cr>')
 | 
			
		||||
    feed('2<C-w><Tab>')
 | 
			
		||||
    execute('yank A')
 | 
			
		||||
    feed_command('yank A')
 | 
			
		||||
 | 
			
		||||
    -- Clean buffer and put register
 | 
			
		||||
    feed('ggdG"ap')
 | 
			
		||||
    execute('1d')
 | 
			
		||||
    feed_command('1d')
 | 
			
		||||
 | 
			
		||||
    -- The buffer should now contain:
 | 
			
		||||
    expect([[
 | 
			
		||||
 
 | 
			
		||||
@@ -2,7 +2,7 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear, feed = helpers.clear, helpers.feed
 | 
			
		||||
local execute, expect = helpers.execute, helpers.expect
 | 
			
		||||
local feed_command, expect = helpers.feed_command, helpers.expect
 | 
			
		||||
 | 
			
		||||
describe('line ending', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
@@ -14,8 +14,8 @@ describe('line ending', function()
 | 
			
		||||
      this one does<C-V><C-M>
 | 
			
		||||
      and the last one doesn't]], '<ESC>')
 | 
			
		||||
 | 
			
		||||
    execute('set ta tx')
 | 
			
		||||
    execute('e!')
 | 
			
		||||
    feed_command('set ta tx')
 | 
			
		||||
    feed_command('e!')
 | 
			
		||||
 | 
			
		||||
    expect("this lines ends in a\r\n"..
 | 
			
		||||
           "this one doesn't\n"..
 | 
			
		||||
 
 | 
			
		||||
@@ -2,7 +2,8 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear, insert = helpers.clear, helpers.insert
 | 
			
		||||
local execute, expect = helpers.execute, helpers.expect
 | 
			
		||||
local command, expect = helpers.command, helpers.expect
 | 
			
		||||
local wait = helpers.wait
 | 
			
		||||
 | 
			
		||||
describe(':edit', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
@@ -12,31 +13,32 @@ describe(':edit', function()
 | 
			
		||||
      The result should be in Xfile1: "fooPIPEbar", in Xfile2: "fooSLASHbar"
 | 
			
		||||
      foo|bar
 | 
			
		||||
      foo/bar]])
 | 
			
		||||
    wait()
 | 
			
		||||
 | 
			
		||||
    -- Prepare some test files
 | 
			
		||||
    execute('$-1w! Xfile1')
 | 
			
		||||
    execute('$w! Xfile2')
 | 
			
		||||
    execute('w! Xfile0')
 | 
			
		||||
    command('$-1w! Xfile1')
 | 
			
		||||
    command('$w! Xfile2')
 | 
			
		||||
    command('w! Xfile0')
 | 
			
		||||
 | 
			
		||||
    -- Open Xfile using '+' range
 | 
			
		||||
    execute('edit +1 Xfile1')
 | 
			
		||||
    execute('s/|/PIPE/')
 | 
			
		||||
    execute('yank A')
 | 
			
		||||
    execute('w! Xfile1')
 | 
			
		||||
    command('edit +1 Xfile1')
 | 
			
		||||
    command('s/|/PIPE/')
 | 
			
		||||
    command('yank A')
 | 
			
		||||
    command('w! Xfile1')
 | 
			
		||||
 | 
			
		||||
    -- Open Xfile2 using '|' range
 | 
			
		||||
    execute('edit Xfile2|1')
 | 
			
		||||
    execute("s/\\//SLASH/")
 | 
			
		||||
    execute('yank A')
 | 
			
		||||
    execute('w! Xfile2')
 | 
			
		||||
    command('edit Xfile2|1')
 | 
			
		||||
    command("s/\\//SLASH/")
 | 
			
		||||
    command('yank A')
 | 
			
		||||
    command('w! Xfile2')
 | 
			
		||||
 | 
			
		||||
    -- Clean first buffer and put @a
 | 
			
		||||
    execute('bf')
 | 
			
		||||
    execute('%d')
 | 
			
		||||
    execute('0put a')
 | 
			
		||||
    command('bf')
 | 
			
		||||
    command('%d')
 | 
			
		||||
    command('0put a')
 | 
			
		||||
 | 
			
		||||
    -- Remove empty line
 | 
			
		||||
    execute('$d')
 | 
			
		||||
    command('$d')
 | 
			
		||||
 | 
			
		||||
    -- The buffer should now contain
 | 
			
		||||
    expect([[
 | 
			
		||||
 
 | 
			
		||||
@@ -3,7 +3,7 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear, feed, insert = helpers.clear, helpers.feed, helpers.insert
 | 
			
		||||
local execute, expect = helpers.execute, helpers.expect
 | 
			
		||||
local feed_command, expect = helpers.feed_command, helpers.expect
 | 
			
		||||
 | 
			
		||||
if helpers.pending_win32(pending) then return end
 | 
			
		||||
 | 
			
		||||
@@ -21,30 +21,30 @@ describe('jump to a tag with hidden set', function()
 | 
			
		||||
 | 
			
		||||
      SECTION_OFF]])
 | 
			
		||||
 | 
			
		||||
    execute('w! Xxx')
 | 
			
		||||
    execute('set hidden')
 | 
			
		||||
    feed_command('w! Xxx')
 | 
			
		||||
    feed_command('set hidden')
 | 
			
		||||
 | 
			
		||||
    -- Create a link from test25.dir to the current directory.
 | 
			
		||||
    execute('!rm -f test25.dir')
 | 
			
		||||
    execute('!ln -s . test25.dir')
 | 
			
		||||
    feed_command('!rm -f test25.dir')
 | 
			
		||||
    feed_command('!ln -s . test25.dir')
 | 
			
		||||
 | 
			
		||||
    -- Create tags.text, with the current directory name inserted.
 | 
			
		||||
    execute('/tags line')
 | 
			
		||||
    execute('r !pwd')
 | 
			
		||||
    feed_command('/tags line')
 | 
			
		||||
    feed_command('r !pwd')
 | 
			
		||||
    feed('d$/test<cr>')
 | 
			
		||||
    feed('hP:.w! tags.test<cr>')
 | 
			
		||||
 | 
			
		||||
    -- Try jumping to a tag in the current file, but with a path that contains a
 | 
			
		||||
    -- symbolic link.  When wrong, this will give the ATTENTION message.  The next
 | 
			
		||||
    -- space will then be eaten by hit-return, instead of moving the cursor to 'd'.
 | 
			
		||||
    execute('set tags=tags.test')
 | 
			
		||||
    feed_command('set tags=tags.test')
 | 
			
		||||
    feed('G<C-]> x:yank a<cr>')
 | 
			
		||||
    execute('!rm -f Xxx test25.dir tags.test')
 | 
			
		||||
    feed_command('!rm -f Xxx test25.dir tags.test')
 | 
			
		||||
 | 
			
		||||
    -- Put @a and remove empty line
 | 
			
		||||
    execute('%d')
 | 
			
		||||
    execute('0put a')
 | 
			
		||||
    execute('$d')
 | 
			
		||||
    feed_command('%d')
 | 
			
		||||
    feed_command('0put a')
 | 
			
		||||
    feed_command('$d')
 | 
			
		||||
 | 
			
		||||
    -- Assert buffer contents.
 | 
			
		||||
    expect("#efine  SECTION_OFF  3")
 | 
			
		||||
 
 | 
			
		||||
@@ -1,9 +1,11 @@
 | 
			
		||||
-- Test for :execute, :while and :if
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
 | 
			
		||||
local clear = helpers.clear
 | 
			
		||||
local execute, expect = helpers.execute, helpers.expect
 | 
			
		||||
local expect = helpers.expect
 | 
			
		||||
local source = helpers.source
 | 
			
		||||
local command = helpers.command
 | 
			
		||||
 | 
			
		||||
describe(':execute, :while and :if', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
@@ -37,7 +39,7 @@ describe(':execute, :while and :if', function()
 | 
			
		||||
    ]])
 | 
			
		||||
 | 
			
		||||
    -- Remove empty line
 | 
			
		||||
    execute('1d')
 | 
			
		||||
    command('1d')
 | 
			
		||||
 | 
			
		||||
    -- Assert buffer contents.
 | 
			
		||||
    expect([[
 | 
			
		||||
 
 | 
			
		||||
@@ -2,7 +2,7 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear, feed, insert = helpers.clear, helpers.feed, helpers.insert
 | 
			
		||||
local execute, expect = helpers.execute, helpers.expect
 | 
			
		||||
local feed_command, expect = helpers.feed_command, helpers.expect
 | 
			
		||||
 | 
			
		||||
describe('CTRL-V at the end of the line', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
@@ -24,8 +24,8 @@ describe('CTRL-V at the end of the line', function()
 | 
			
		||||
 | 
			
		||||
    feed(':%s/X/<C-v><C-v>/g<cr>')
 | 
			
		||||
    feed(':/firstline/+1,/lastline/-1w! Xtestfile<cr>')
 | 
			
		||||
    execute('so Xtestfile')
 | 
			
		||||
    execute('%d')
 | 
			
		||||
    feed_command('so Xtestfile')
 | 
			
		||||
    feed_command('%d')
 | 
			
		||||
    feed('Gmm__1<Esc><Esc>__2<Esc>__3<Esc><Esc>__4<Esc>__5<Esc>')
 | 
			
		||||
    feed(":'m,$s/<C-v><C-@>/0/g<cr>")
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
@@ -1,8 +1,9 @@
 | 
			
		||||
-- Test for a lot of variations of the 'fileformats' option
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local feed, clear, execute = helpers.feed, helpers.clear, helpers.execute
 | 
			
		||||
local feed, clear, command = helpers.feed, helpers.clear, helpers.command
 | 
			
		||||
local eq, write_file = helpers.eq, helpers.write_file
 | 
			
		||||
local wait = helpers.wait
 | 
			
		||||
 | 
			
		||||
if helpers.pending_win32(pending) then return end
 | 
			
		||||
 | 
			
		||||
@@ -45,198 +46,214 @@ describe('fileformats option', function()
 | 
			
		||||
  it('is working', function()
 | 
			
		||||
 | 
			
		||||
    -- Try reading and writing with 'fileformats' empty.
 | 
			
		||||
    execute('set fileformats=')
 | 
			
		||||
    execute('set fileformat=unix')
 | 
			
		||||
    execute('e! XXUnix')
 | 
			
		||||
    execute('w! test.out')
 | 
			
		||||
    execute('e! XXDos')
 | 
			
		||||
    execute('w! XXtt01')
 | 
			
		||||
    execute('e! XXMac')
 | 
			
		||||
    execute('w! XXtt02')
 | 
			
		||||
    execute('bwipe XXUnix XXDos XXMac')
 | 
			
		||||
    execute('set fileformat=dos')
 | 
			
		||||
    execute('e! XXUnix')
 | 
			
		||||
    execute('w! XXtt11')
 | 
			
		||||
    execute('e! XXDos')
 | 
			
		||||
    execute('w! XXtt12')
 | 
			
		||||
    execute('e! XXMac')
 | 
			
		||||
    execute('w! XXtt13')
 | 
			
		||||
    execute('bwipe XXUnix XXDos XXMac')
 | 
			
		||||
    execute('set fileformat=mac')
 | 
			
		||||
    execute('e! XXUnix')
 | 
			
		||||
    execute('w! XXtt21')
 | 
			
		||||
    execute('e! XXDos')
 | 
			
		||||
    execute('w! XXtt22')
 | 
			
		||||
    execute('e! XXMac')
 | 
			
		||||
    execute('w! XXtt23')
 | 
			
		||||
    execute('bwipe XXUnix XXDos XXMac')
 | 
			
		||||
    command('set fileformats=')
 | 
			
		||||
    command('set fileformat=unix')
 | 
			
		||||
    command('e! XXUnix')
 | 
			
		||||
    command('w! test.out')
 | 
			
		||||
    command('e! XXDos')
 | 
			
		||||
    command('w! XXtt01')
 | 
			
		||||
    command('e! XXMac')
 | 
			
		||||
    command('w! XXtt02')
 | 
			
		||||
    command('bwipe XXUnix XXDos XXMac')
 | 
			
		||||
    command('set fileformat=dos')
 | 
			
		||||
    command('e! XXUnix')
 | 
			
		||||
    command('w! XXtt11')
 | 
			
		||||
    command('e! XXDos')
 | 
			
		||||
    command('w! XXtt12')
 | 
			
		||||
    command('e! XXMac')
 | 
			
		||||
    command('w! XXtt13')
 | 
			
		||||
    command('bwipe XXUnix XXDos XXMac')
 | 
			
		||||
    command('set fileformat=mac')
 | 
			
		||||
    command('e! XXUnix')
 | 
			
		||||
    command('w! XXtt21')
 | 
			
		||||
    command('e! XXDos')
 | 
			
		||||
    command('w! XXtt22')
 | 
			
		||||
    command('e! XXMac')
 | 
			
		||||
    command('w! XXtt23')
 | 
			
		||||
    command('bwipe XXUnix XXDos XXMac')
 | 
			
		||||
 | 
			
		||||
    -- Try reading and writing with 'fileformats' set to one format.
 | 
			
		||||
    execute('set fileformats=unix')
 | 
			
		||||
    execute('e! XXUxDsMc')
 | 
			
		||||
    execute('w! XXtt31')
 | 
			
		||||
    execute('bwipe XXUxDsMc')
 | 
			
		||||
    execute('set fileformats=dos')
 | 
			
		||||
    execute('e! XXUxDsMc')
 | 
			
		||||
    execute('w! XXtt32')
 | 
			
		||||
    execute('bwipe XXUxDsMc')
 | 
			
		||||
    execute('set fileformats=mac')
 | 
			
		||||
    execute('e! XXUxDsMc')
 | 
			
		||||
    execute('w! XXtt33')
 | 
			
		||||
    execute('bwipe XXUxDsMc')
 | 
			
		||||
    command('set fileformats=unix')
 | 
			
		||||
    command('e! XXUxDsMc')
 | 
			
		||||
    command('w! XXtt31')
 | 
			
		||||
    command('bwipe XXUxDsMc')
 | 
			
		||||
    command('set fileformats=dos')
 | 
			
		||||
    command('e! XXUxDsMc')
 | 
			
		||||
    command('w! XXtt32')
 | 
			
		||||
    command('bwipe XXUxDsMc')
 | 
			
		||||
    command('set fileformats=mac')
 | 
			
		||||
    command('e! XXUxDsMc')
 | 
			
		||||
    command('w! XXtt33')
 | 
			
		||||
    command('bwipe XXUxDsMc')
 | 
			
		||||
 | 
			
		||||
    -- Try reading and writing with 'fileformats' set to two formats.
 | 
			
		||||
    execute('set fileformats=unix,dos')
 | 
			
		||||
    execute('e! XXUxDsMc')
 | 
			
		||||
    execute('w! XXtt41')
 | 
			
		||||
    execute('bwipe XXUxDsMc')
 | 
			
		||||
    execute('e! XXUxMac')
 | 
			
		||||
    execute('w! XXtt42')
 | 
			
		||||
    execute('bwipe XXUxMac')
 | 
			
		||||
    execute('e! XXDosMac')
 | 
			
		||||
    execute('w! XXtt43')
 | 
			
		||||
    execute('bwipe XXDosMac')
 | 
			
		||||
    execute('set fileformats=unix,mac')
 | 
			
		||||
    execute('e! XXUxDs')
 | 
			
		||||
    execute('w! XXtt51')
 | 
			
		||||
    execute('bwipe XXUxDs')
 | 
			
		||||
    execute('e! XXUxDsMc')
 | 
			
		||||
    execute('w! XXtt52')
 | 
			
		||||
    execute('bwipe XXUxDsMc')
 | 
			
		||||
    execute('e! XXDosMac')
 | 
			
		||||
    execute('w! XXtt53')
 | 
			
		||||
    execute('bwipe XXDosMac')
 | 
			
		||||
    execute('e! XXEol')
 | 
			
		||||
    command('set fileformats=unix,dos')
 | 
			
		||||
    command('e! XXUxDsMc')
 | 
			
		||||
    command('w! XXtt41')
 | 
			
		||||
    command('bwipe XXUxDsMc')
 | 
			
		||||
    command('e! XXUxMac')
 | 
			
		||||
    command('w! XXtt42')
 | 
			
		||||
    command('bwipe XXUxMac')
 | 
			
		||||
    command('e! XXDosMac')
 | 
			
		||||
    command('w! XXtt43')
 | 
			
		||||
    command('bwipe XXDosMac')
 | 
			
		||||
    command('set fileformats=unix,mac')
 | 
			
		||||
    command('e! XXUxDs')
 | 
			
		||||
    command('w! XXtt51')
 | 
			
		||||
    command('bwipe XXUxDs')
 | 
			
		||||
    command('e! XXUxDsMc')
 | 
			
		||||
    command('w! XXtt52')
 | 
			
		||||
    command('bwipe XXUxDsMc')
 | 
			
		||||
    command('e! XXDosMac')
 | 
			
		||||
    command('w! XXtt53')
 | 
			
		||||
    command('bwipe XXDosMac')
 | 
			
		||||
    command('e! XXEol')
 | 
			
		||||
    feed('ggO<C-R>=&ffs<CR>:<C-R>=&ff<CR><ESC>')
 | 
			
		||||
    execute('w! XXtt54')
 | 
			
		||||
    execute('bwipe XXEol')
 | 
			
		||||
    execute('set fileformats=dos,mac')
 | 
			
		||||
    execute('e! XXUxDs')
 | 
			
		||||
    execute('w! XXtt61')
 | 
			
		||||
    execute('bwipe XXUxDs')
 | 
			
		||||
    execute('e! XXUxMac')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('w! XXtt54')
 | 
			
		||||
    command('bwipe XXEol')
 | 
			
		||||
    command('set fileformats=dos,mac')
 | 
			
		||||
    command('e! XXUxDs')
 | 
			
		||||
    command('w! XXtt61')
 | 
			
		||||
    command('bwipe XXUxDs')
 | 
			
		||||
    command('e! XXUxMac')
 | 
			
		||||
    feed('ggO<C-R>=&ffs<CR>:<C-R>=&ff<CR><ESC>')
 | 
			
		||||
    execute('w! XXtt62')
 | 
			
		||||
    execute('bwipe XXUxMac')
 | 
			
		||||
    execute('e! XXUxDsMc')
 | 
			
		||||
    execute('w! XXtt63')
 | 
			
		||||
    execute('bwipe XXUxDsMc')
 | 
			
		||||
    execute('e! XXMacEol')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('w! XXtt62')
 | 
			
		||||
    command('bwipe XXUxMac')
 | 
			
		||||
    command('e! XXUxDsMc')
 | 
			
		||||
    command('w! XXtt63')
 | 
			
		||||
    command('bwipe XXUxDsMc')
 | 
			
		||||
    command('e! XXMacEol')
 | 
			
		||||
    feed('ggO<C-R>=&ffs<CR>:<C-R>=&ff<CR><ESC>')
 | 
			
		||||
    execute('w! XXtt64')
 | 
			
		||||
    execute('bwipe XXMacEol')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('w! XXtt64')
 | 
			
		||||
    command('bwipe XXMacEol')
 | 
			
		||||
 | 
			
		||||
    -- Try reading and writing with 'fileformats' set to three formats.
 | 
			
		||||
    execute('set fileformats=unix,dos,mac')
 | 
			
		||||
    execute('e! XXUxDsMc')
 | 
			
		||||
    execute('w! XXtt71')
 | 
			
		||||
    execute('bwipe XXUxDsMc')
 | 
			
		||||
    execute('e! XXEol')
 | 
			
		||||
    command('set fileformats=unix,dos,mac')
 | 
			
		||||
    command('e! XXUxDsMc')
 | 
			
		||||
    command('w! XXtt71')
 | 
			
		||||
    command('bwipe XXUxDsMc')
 | 
			
		||||
    command('e! XXEol')
 | 
			
		||||
    feed('ggO<C-R>=&ffs<CR>:<C-R>=&ff<CR><ESC>')
 | 
			
		||||
    execute('w! XXtt72')
 | 
			
		||||
    execute('bwipe XXEol')
 | 
			
		||||
    execute('set fileformats=mac,dos,unix')
 | 
			
		||||
    execute('e! XXUxDsMc')
 | 
			
		||||
    execute('w! XXtt81')
 | 
			
		||||
    execute('bwipe XXUxDsMc')
 | 
			
		||||
    execute('e! XXEol')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('w! XXtt72')
 | 
			
		||||
    command('bwipe XXEol')
 | 
			
		||||
    command('set fileformats=mac,dos,unix')
 | 
			
		||||
    command('e! XXUxDsMc')
 | 
			
		||||
    command('w! XXtt81')
 | 
			
		||||
    command('bwipe XXUxDsMc')
 | 
			
		||||
    command('e! XXEol')
 | 
			
		||||
    feed('ggO<C-R>=&ffs<CR>:<C-R>=&ff<CR><ESC>')
 | 
			
		||||
    execute('w! XXtt82')
 | 
			
		||||
    execute('bwipe XXEol')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('w! XXtt82')
 | 
			
		||||
    command('bwipe XXEol')
 | 
			
		||||
    -- Try with 'binary' set.
 | 
			
		||||
    execute('set fileformats=mac,unix,dos')
 | 
			
		||||
    execute('set binary')
 | 
			
		||||
    execute('e! XXUxDsMc')
 | 
			
		||||
    execute('w! XXtt91')
 | 
			
		||||
    execute('bwipe XXUxDsMc')
 | 
			
		||||
    execute('set fileformats=mac')
 | 
			
		||||
    execute('e! XXUxDsMc')
 | 
			
		||||
    execute('w! XXtt92')
 | 
			
		||||
    execute('bwipe XXUxDsMc')
 | 
			
		||||
    execute('set fileformats=dos')
 | 
			
		||||
    execute('e! XXUxDsMc')
 | 
			
		||||
    execute('w! XXtt93')
 | 
			
		||||
    command('set fileformats=mac,unix,dos')
 | 
			
		||||
    command('set binary')
 | 
			
		||||
    command('e! XXUxDsMc')
 | 
			
		||||
    command('w! XXtt91')
 | 
			
		||||
    command('bwipe XXUxDsMc')
 | 
			
		||||
    command('set fileformats=mac')
 | 
			
		||||
    command('e! XXUxDsMc')
 | 
			
		||||
    command('w! XXtt92')
 | 
			
		||||
    command('bwipe XXUxDsMc')
 | 
			
		||||
    command('set fileformats=dos')
 | 
			
		||||
    command('e! XXUxDsMc')
 | 
			
		||||
    command('w! XXtt93')
 | 
			
		||||
 | 
			
		||||
    -- Append "END" to each file so that we can see what the last written
 | 
			
		||||
    -- char was.
 | 
			
		||||
    execute('set fileformat=unix nobin')
 | 
			
		||||
    command('set fileformat=unix nobin')
 | 
			
		||||
    feed('ggdGaEND<esc>')
 | 
			
		||||
    execute('w >>XXtt01')
 | 
			
		||||
    execute('w >>XXtt02')
 | 
			
		||||
    execute('w >>XXtt11')
 | 
			
		||||
    execute('w >>XXtt12')
 | 
			
		||||
    execute('w >>XXtt13')
 | 
			
		||||
    execute('w >>XXtt21')
 | 
			
		||||
    execute('w >>XXtt22')
 | 
			
		||||
    execute('w >>XXtt23')
 | 
			
		||||
    execute('w >>XXtt31')
 | 
			
		||||
    execute('w >>XXtt32')
 | 
			
		||||
    execute('w >>XXtt33')
 | 
			
		||||
    execute('w >>XXtt41')
 | 
			
		||||
    execute('w >>XXtt42')
 | 
			
		||||
    execute('w >>XXtt43')
 | 
			
		||||
    execute('w >>XXtt51')
 | 
			
		||||
    execute('w >>XXtt52')
 | 
			
		||||
    execute('w >>XXtt53')
 | 
			
		||||
    execute('w >>XXtt54')
 | 
			
		||||
    execute('w >>XXtt61')
 | 
			
		||||
    execute('w >>XXtt62')
 | 
			
		||||
    execute('w >>XXtt63')
 | 
			
		||||
    execute('w >>XXtt64')
 | 
			
		||||
    execute('w >>XXtt71')
 | 
			
		||||
    execute('w >>XXtt72')
 | 
			
		||||
    execute('w >>XXtt81')
 | 
			
		||||
    execute('w >>XXtt82')
 | 
			
		||||
    execute('w >>XXtt91')
 | 
			
		||||
    execute('w >>XXtt92')
 | 
			
		||||
    execute('w >>XXtt93')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('w >>XXtt01')
 | 
			
		||||
    command('w >>XXtt02')
 | 
			
		||||
    command('w >>XXtt11')
 | 
			
		||||
    command('w >>XXtt12')
 | 
			
		||||
    command('w >>XXtt13')
 | 
			
		||||
    command('w >>XXtt21')
 | 
			
		||||
    command('w >>XXtt22')
 | 
			
		||||
    command('w >>XXtt23')
 | 
			
		||||
    command('w >>XXtt31')
 | 
			
		||||
    command('w >>XXtt32')
 | 
			
		||||
    command('w >>XXtt33')
 | 
			
		||||
    command('w >>XXtt41')
 | 
			
		||||
    command('w >>XXtt42')
 | 
			
		||||
    command('w >>XXtt43')
 | 
			
		||||
    command('w >>XXtt51')
 | 
			
		||||
    command('w >>XXtt52')
 | 
			
		||||
    command('w >>XXtt53')
 | 
			
		||||
    command('w >>XXtt54')
 | 
			
		||||
    command('w >>XXtt61')
 | 
			
		||||
    command('w >>XXtt62')
 | 
			
		||||
    command('w >>XXtt63')
 | 
			
		||||
    command('w >>XXtt64')
 | 
			
		||||
    command('w >>XXtt71')
 | 
			
		||||
    command('w >>XXtt72')
 | 
			
		||||
    command('w >>XXtt81')
 | 
			
		||||
    command('w >>XXtt82')
 | 
			
		||||
    command('w >>XXtt91')
 | 
			
		||||
    command('w >>XXtt92')
 | 
			
		||||
    command('w >>XXtt93')
 | 
			
		||||
 | 
			
		||||
    -- Concatenate the results.
 | 
			
		||||
    -- Make fileformat of test.out the native fileformat.
 | 
			
		||||
    -- Add a newline at the end.
 | 
			
		||||
    execute('set binary')
 | 
			
		||||
    execute('e! test.out')
 | 
			
		||||
    execute('$r XXtt01')
 | 
			
		||||
    execute('$r XXtt02')
 | 
			
		||||
    command('set binary')
 | 
			
		||||
    command('e! test.out')
 | 
			
		||||
    command('$r XXtt01')
 | 
			
		||||
    command('$r XXtt02')
 | 
			
		||||
    feed('Go1<esc>')
 | 
			
		||||
    execute('$r XXtt11')
 | 
			
		||||
    execute('$r XXtt12')
 | 
			
		||||
    execute('$r XXtt13')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('$r XXtt11')
 | 
			
		||||
    command('$r XXtt12')
 | 
			
		||||
    command('$r XXtt13')
 | 
			
		||||
    feed('Go2<esc>')
 | 
			
		||||
    execute('$r XXtt21')
 | 
			
		||||
    execute('$r XXtt22')
 | 
			
		||||
    execute('$r XXtt23')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('$r XXtt21')
 | 
			
		||||
    command('$r XXtt22')
 | 
			
		||||
    command('$r XXtt23')
 | 
			
		||||
    feed('Go3<esc>')
 | 
			
		||||
    execute('$r XXtt31')
 | 
			
		||||
    execute('$r XXtt32')
 | 
			
		||||
    execute('$r XXtt33')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('$r XXtt31')
 | 
			
		||||
    command('$r XXtt32')
 | 
			
		||||
    command('$r XXtt33')
 | 
			
		||||
    feed('Go4<esc>')
 | 
			
		||||
    execute('$r XXtt41')
 | 
			
		||||
    execute('$r XXtt42')
 | 
			
		||||
    execute('$r XXtt43')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('$r XXtt41')
 | 
			
		||||
    command('$r XXtt42')
 | 
			
		||||
    command('$r XXtt43')
 | 
			
		||||
    feed('Go5<esc>')
 | 
			
		||||
    execute('$r XXtt51')
 | 
			
		||||
    execute('$r XXtt52')
 | 
			
		||||
    execute('$r XXtt53')
 | 
			
		||||
    execute('$r XXtt54')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('$r XXtt51')
 | 
			
		||||
    command('$r XXtt52')
 | 
			
		||||
    command('$r XXtt53')
 | 
			
		||||
    command('$r XXtt54')
 | 
			
		||||
    feed('Go6<esc>')
 | 
			
		||||
    execute('$r XXtt61')
 | 
			
		||||
    execute('$r XXtt62')
 | 
			
		||||
    execute('$r XXtt63')
 | 
			
		||||
    execute('$r XXtt64')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('$r XXtt61')
 | 
			
		||||
    command('$r XXtt62')
 | 
			
		||||
    command('$r XXtt63')
 | 
			
		||||
    command('$r XXtt64')
 | 
			
		||||
    feed('Go7<esc>')
 | 
			
		||||
    execute('$r XXtt71')
 | 
			
		||||
    execute('$r XXtt72')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('$r XXtt71')
 | 
			
		||||
    command('$r XXtt72')
 | 
			
		||||
    feed('Go8<esc>')
 | 
			
		||||
    execute('$r XXtt81')
 | 
			
		||||
    execute('$r XXtt82')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('$r XXtt81')
 | 
			
		||||
    command('$r XXtt82')
 | 
			
		||||
    feed('Go9<esc>')
 | 
			
		||||
    execute('$r XXtt91')
 | 
			
		||||
    execute('$r XXtt92')
 | 
			
		||||
    execute('$r XXtt93')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('$r XXtt91')
 | 
			
		||||
    command('$r XXtt92')
 | 
			
		||||
    command('$r XXtt93')
 | 
			
		||||
    feed('Go10<esc>')
 | 
			
		||||
    execute('$r XXUnix')
 | 
			
		||||
    execute('set nobinary ff&')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('$r XXUnix')
 | 
			
		||||
    command('set nobinary ff&')
 | 
			
		||||
 | 
			
		||||
    -- Assert buffer contents.  This has to be done manually as
 | 
			
		||||
    -- helpers.expect() calls helpers.dedent() which messes up the white space
 | 
			
		||||
 
 | 
			
		||||
@@ -16,7 +16,7 @@ local clear = helpers.clear
 | 
			
		||||
local source = helpers.source
 | 
			
		||||
local insert = helpers.insert
 | 
			
		||||
local expect = helpers.expect
 | 
			
		||||
local execute = helpers.execute
 | 
			
		||||
local feed_command = helpers.feed_command
 | 
			
		||||
 | 
			
		||||
describe('Commands that close windows and/or buffers', function()
 | 
			
		||||
  local function cleanup()
 | 
			
		||||
@@ -38,40 +38,40 @@ describe('Commands that close windows and/or buffers', function()
 | 
			
		||||
    feed('GA 1<Esc>:$w! Xtest1<CR>')
 | 
			
		||||
    feed('$r2:$w! Xtest2<CR>')
 | 
			
		||||
    feed('$r3:$w! Xtest3<CR>')
 | 
			
		||||
    execute('n! Xtest1 Xtest2')
 | 
			
		||||
    feed_command('n! Xtest1 Xtest2')
 | 
			
		||||
    feed('A 1<Esc>:set hidden<CR>')
 | 
			
		||||
 | 
			
		||||
    -- Test for working :n when hidden set
 | 
			
		||||
    execute('n')
 | 
			
		||||
    feed_command('n')
 | 
			
		||||
    expect('testtext 2')
 | 
			
		||||
 | 
			
		||||
    -- Test for failing :rew when hidden not set
 | 
			
		||||
    execute('set nohidden')
 | 
			
		||||
    feed_command('set nohidden')
 | 
			
		||||
    feed('A 2<Esc>:rew<CR>')
 | 
			
		||||
    expect('testtext 2 2')
 | 
			
		||||
 | 
			
		||||
    -- Test for working :rew when hidden set
 | 
			
		||||
    execute('set hidden')
 | 
			
		||||
    execute('rew')
 | 
			
		||||
    feed_command('set hidden')
 | 
			
		||||
    feed_command('rew')
 | 
			
		||||
    expect('testtext 1 1')
 | 
			
		||||
 | 
			
		||||
    -- Test for :all keeping a buffer when it's modified
 | 
			
		||||
    execute('set nohidden')
 | 
			
		||||
    feed_command('set nohidden')
 | 
			
		||||
    feed('A 1<Esc>:sp<CR>')
 | 
			
		||||
    execute('n Xtest2 Xtest3')
 | 
			
		||||
    execute('all')
 | 
			
		||||
    execute('1wincmd w')
 | 
			
		||||
    feed_command('n Xtest2 Xtest3')
 | 
			
		||||
    feed_command('all')
 | 
			
		||||
    feed_command('1wincmd w')
 | 
			
		||||
    expect('testtext 1 1 1')
 | 
			
		||||
 | 
			
		||||
    -- Test abandoning changed buffer, should be unloaded even when 'hidden' set
 | 
			
		||||
    execute('set hidden')
 | 
			
		||||
    feed_command('set hidden')
 | 
			
		||||
    feed('A 1<Esc>:q!<CR>')
 | 
			
		||||
    expect('testtext 2 2')
 | 
			
		||||
    execute('unhide')
 | 
			
		||||
    feed_command('unhide')
 | 
			
		||||
    expect('testtext 2 2')
 | 
			
		||||
 | 
			
		||||
    -- Test ":hide" hides anyway when 'hidden' not set
 | 
			
		||||
    execute('set nohidden')
 | 
			
		||||
    feed_command('set nohidden')
 | 
			
		||||
    feed('A 2<Esc>:hide<CR>')
 | 
			
		||||
    expect('testtext 3')
 | 
			
		||||
 | 
			
		||||
@@ -80,42 +80,42 @@ describe('Commands that close windows and/or buffers', function()
 | 
			
		||||
    expect('testtext 3 3')
 | 
			
		||||
 | 
			
		||||
    -- Test ":edit" working in modified buffer when 'hidden' set
 | 
			
		||||
    execute('set hidden')
 | 
			
		||||
    execute('e Xtest1')
 | 
			
		||||
    feed_command('set hidden')
 | 
			
		||||
    feed_command('e Xtest1')
 | 
			
		||||
    expect('testtext 1')
 | 
			
		||||
 | 
			
		||||
    -- Test ":close" not hiding when 'hidden' not set in modified buffer
 | 
			
		||||
    execute('sp Xtest3')
 | 
			
		||||
    execute('set nohidden')
 | 
			
		||||
    feed_command('sp Xtest3')
 | 
			
		||||
    feed_command('set nohidden')
 | 
			
		||||
    feed('A 3<Esc>:close<CR>')
 | 
			
		||||
    expect('testtext 3 3 3')
 | 
			
		||||
 | 
			
		||||
    -- Test ":close!" does hide when 'hidden' not set in modified buffer
 | 
			
		||||
    feed('A 3<Esc>:close!<CR>')
 | 
			
		||||
    execute('set nohidden')
 | 
			
		||||
    feed_command('set nohidden')
 | 
			
		||||
    expect('testtext 1')
 | 
			
		||||
 | 
			
		||||
    -- Test ":all!" hides changed buffer
 | 
			
		||||
    execute('sp Xtest4')
 | 
			
		||||
    feed_command('sp Xtest4')
 | 
			
		||||
    feed('GA 4<Esc>:all!<CR>')
 | 
			
		||||
    execute('1wincmd w')
 | 
			
		||||
    feed_command('1wincmd w')
 | 
			
		||||
    expect('testtext 2 2 2')
 | 
			
		||||
 | 
			
		||||
    -- Test ":q!" and hidden buffer.
 | 
			
		||||
    execute('bw! Xtest1 Xtest2 Xtest3 Xtest4')
 | 
			
		||||
    execute('sp Xtest1')
 | 
			
		||||
    execute('wincmd w')
 | 
			
		||||
    execute('bw!')
 | 
			
		||||
    execute('set modified')
 | 
			
		||||
    execute('bot sp Xtest2')
 | 
			
		||||
    execute('set modified')
 | 
			
		||||
    execute('bot sp Xtest3')
 | 
			
		||||
    execute('set modified')
 | 
			
		||||
    execute('wincmd t')
 | 
			
		||||
    execute('hide')
 | 
			
		||||
    execute('q!')
 | 
			
		||||
    feed_command('bw! Xtest1 Xtest2 Xtest3 Xtest4')
 | 
			
		||||
    feed_command('sp Xtest1')
 | 
			
		||||
    feed_command('wincmd w')
 | 
			
		||||
    feed_command('bw!')
 | 
			
		||||
    feed_command('set modified')
 | 
			
		||||
    feed_command('bot sp Xtest2')
 | 
			
		||||
    feed_command('set modified')
 | 
			
		||||
    feed_command('bot sp Xtest3')
 | 
			
		||||
    feed_command('set modified')
 | 
			
		||||
    feed_command('wincmd t')
 | 
			
		||||
    feed_command('hide')
 | 
			
		||||
    feed_command('q!')
 | 
			
		||||
    expect('testtext 3')
 | 
			
		||||
    execute('q!')
 | 
			
		||||
    feed_command('q!')
 | 
			
		||||
    feed('<CR>')
 | 
			
		||||
    expect('testtext 1')
 | 
			
		||||
    source([[
 | 
			
		||||
 
 | 
			
		||||
@@ -1,10 +1,10 @@
 | 
			
		||||
-- vim: set foldmethod=marker foldmarker=[[,]] :
 | 
			
		||||
-- Test for 'lisp'
 | 
			
		||||
-- If the lisp feature is not enabled, this will fail!
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear, feed, insert = helpers.clear, helpers.feed, helpers.insert
 | 
			
		||||
local execute, expect = helpers.execute, helpers.expect
 | 
			
		||||
local command, expect = helpers.command, helpers.expect
 | 
			
		||||
local wait = helpers.wait
 | 
			
		||||
 | 
			
		||||
describe('lisp indent', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
@@ -35,14 +35,15 @@ describe('lisp indent', function()
 | 
			
		||||
      ,@body
 | 
			
		||||
      (princ "</a>")))]])
 | 
			
		||||
 | 
			
		||||
    execute('set lisp')
 | 
			
		||||
    execute('/^(defun')
 | 
			
		||||
    command('set lisp')
 | 
			
		||||
    command('/^(defun')
 | 
			
		||||
    feed('=G:/^(defun/,$yank A<cr>')
 | 
			
		||||
    wait()
 | 
			
		||||
 | 
			
		||||
    -- Put @a and clean empty line
 | 
			
		||||
    execute('%d')
 | 
			
		||||
    execute('0put a')
 | 
			
		||||
    execute('$d')
 | 
			
		||||
    command('%d')
 | 
			
		||||
    command('0put a')
 | 
			
		||||
    command('$d')
 | 
			
		||||
 | 
			
		||||
    -- Assert buffer contents.
 | 
			
		||||
    expect([[
 | 
			
		||||
 
 | 
			
		||||
@@ -5,7 +5,7 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local feed, insert, source = helpers.feed, helpers.insert, helpers.source
 | 
			
		||||
local clear, execute, expect = helpers.clear, helpers.execute, helpers.expect
 | 
			
		||||
local clear, feed_command, expect = helpers.clear, helpers.feed_command, helpers.expect
 | 
			
		||||
 | 
			
		||||
describe('user functions, expr-mappings, overwrite protected builtin functions and regression on calling expressions', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
@@ -72,19 +72,19 @@ describe('user functions, expr-mappings, overwrite protected builtin functions a
 | 
			
		||||
    feed('(one<cr>')
 | 
			
		||||
    feed('(two<cr>')
 | 
			
		||||
    feed('[(one again<esc>')
 | 
			
		||||
    execute('call append(line("$"), max([1, 2, 3]))')
 | 
			
		||||
    execute('call extend(g:, {"max": function("min")})')
 | 
			
		||||
    execute('call append(line("$"), max([1, 2, 3]))')
 | 
			
		||||
    execute('try')
 | 
			
		||||
    feed_command('call append(line("$"), max([1, 2, 3]))')
 | 
			
		||||
    feed_command('call extend(g:, {"max": function("min")})')
 | 
			
		||||
    feed_command('call append(line("$"), max([1, 2, 3]))')
 | 
			
		||||
    feed_command('try')
 | 
			
		||||
    -- Regression: the first line below used to throw "E110: Missing ')'"
 | 
			
		||||
    -- Second is here just to prove that this line is correct when not
 | 
			
		||||
    -- skipping rhs of &&.
 | 
			
		||||
    execute([[    $put =(0&&(function('tr'))(1, 2, 3))]])
 | 
			
		||||
    execute([[    $put =(1&&(function('tr'))(1, 2, 3))]])
 | 
			
		||||
    execute('catch')
 | 
			
		||||
    execute([[    $put ='!!! Unexpected exception:']])
 | 
			
		||||
    execute('    $put =v:exception')
 | 
			
		||||
    execute('endtry')
 | 
			
		||||
    feed_command([[    $put =(0&&(function('tr'))(1, 2, 3))]])
 | 
			
		||||
    feed_command([[    $put =(1&&(function('tr'))(1, 2, 3))]])
 | 
			
		||||
    feed_command('catch')
 | 
			
		||||
    feed_command([[    $put ='!!! Unexpected exception:']])
 | 
			
		||||
    feed_command('    $put =v:exception')
 | 
			
		||||
    feed_command('endtry')
 | 
			
		||||
 | 
			
		||||
    -- Assert buffer contents.
 | 
			
		||||
    expect([[
 | 
			
		||||
 
 | 
			
		||||
@@ -3,7 +3,7 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear, feed, insert = helpers.clear, helpers.feed, helpers.insert
 | 
			
		||||
local execute, expect = helpers.execute, helpers.expect
 | 
			
		||||
local feed_command, expect = helpers.feed_command, helpers.expect
 | 
			
		||||
 | 
			
		||||
describe('increment and decrement commands', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
@@ -19,25 +19,25 @@ describe('increment and decrement commands', function()
 | 
			
		||||
 | 
			
		||||
    -- Increment and decrement numbers in the first row, interpreting the
 | 
			
		||||
    -- numbers as decimal, octal or hexadecimal.
 | 
			
		||||
    execute('set nrformats=bin,octal,hex', '1')
 | 
			
		||||
    feed_command('set nrformats=bin,octal,hex', '1')
 | 
			
		||||
    feed('63l102ll64128$')
 | 
			
		||||
 | 
			
		||||
    -- For the second row, treat the numbers as decimal or octal.
 | 
			
		||||
    -- 0x100 should be interpreted as decimal 0, the character x, and decimal 100.
 | 
			
		||||
    execute('set nrformats=octal', '2')
 | 
			
		||||
    feed_command('set nrformats=octal', '2')
 | 
			
		||||
    feed('0w102l2w65129blx6lD')
 | 
			
		||||
 | 
			
		||||
    -- For the third row, treat the numbers as decimal or hexadecimal.
 | 
			
		||||
    -- 077 should be interpreted as decimal 77.
 | 
			
		||||
    execute('set nrformats=hex', '3')
 | 
			
		||||
    feed_command('set nrformats=hex', '3')
 | 
			
		||||
    feed('0101l257Txldt   ')
 | 
			
		||||
 | 
			
		||||
    -- For the fourth row, interpret all numbers as decimal.
 | 
			
		||||
    execute('set nrformats=', '4')
 | 
			
		||||
    feed_command('set nrformats=', '4')
 | 
			
		||||
    feed('0200l100w78')
 | 
			
		||||
 | 
			
		||||
    -- For the last row, interpret as binary and hexadecimal.
 | 
			
		||||
    execute('set nrformats=bin,hex', '5')
 | 
			
		||||
    feed_command('set nrformats=bin,hex', '5')
 | 
			
		||||
    feed('010065l6432')
 | 
			
		||||
 | 
			
		||||
    expect([[
 | 
			
		||||
 
 | 
			
		||||
@@ -1,7 +1,7 @@
 | 
			
		||||
-- Test character classes in regexp using regexpengine 0, 1, 2.
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear, execute, expect = helpers.clear, helpers.execute, helpers.expect
 | 
			
		||||
local clear, command, expect = helpers.clear, helpers.command, helpers.expect
 | 
			
		||||
local source, write_file = helpers.source, helpers.write_file
 | 
			
		||||
 | 
			
		||||
local function sixlines(text)
 | 
			
		||||
@@ -14,7 +14,7 @@ end
 | 
			
		||||
 | 
			
		||||
local function diff(text, nodedent)
 | 
			
		||||
  local fname = helpers.tmpname()
 | 
			
		||||
  execute('w! '..fname)
 | 
			
		||||
  command('w! '..fname)
 | 
			
		||||
  helpers.wait()
 | 
			
		||||
  local data = io.open(fname):read('*all')
 | 
			
		||||
  if nodedent then
 | 
			
		||||
@@ -45,7 +45,7 @@ describe('character classes in regexp', function()
 | 
			
		||||
  end)
 | 
			
		||||
  before_each(function()
 | 
			
		||||
    clear()
 | 
			
		||||
    execute('e test36.in')
 | 
			
		||||
    command('e test36.in')
 | 
			
		||||
  end)
 | 
			
		||||
  teardown(function()
 | 
			
		||||
    os.remove('test36.in')
 | 
			
		||||
 
 | 
			
		||||
@@ -2,31 +2,31 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local feed = helpers.feed
 | 
			
		||||
local clear, execute, expect = helpers.clear, helpers.execute, helpers.expect
 | 
			
		||||
local clear, feed_command, expect = helpers.clear, helpers.feed_command, helpers.expect
 | 
			
		||||
 | 
			
		||||
describe('Virtual replace mode', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
 | 
			
		||||
  it('is working', function()
 | 
			
		||||
    -- Make sure that backspace works, no matter what termcap is used.
 | 
			
		||||
    execute('set t_kD=x7f t_kb=x08')
 | 
			
		||||
    feed_command('set t_kD=x7f t_kb=x08')
 | 
			
		||||
    -- Use vi default for 'smarttab'
 | 
			
		||||
    execute('set nosmarttab')
 | 
			
		||||
    feed_command('set nosmarttab')
 | 
			
		||||
    feed('ggdGa<cr>')
 | 
			
		||||
    feed('abcdefghi<cr>')
 | 
			
		||||
    feed('jk<tab>lmn<cr>')
 | 
			
		||||
    feed('<Space><Space><Space><Space>opq<tab>rst<cr>')
 | 
			
		||||
    feed('<C-d>uvwxyz<cr>')
 | 
			
		||||
    feed('<esc>gg')
 | 
			
		||||
    execute('set ai')
 | 
			
		||||
    execute('set bs=2')
 | 
			
		||||
    feed_command('set ai')
 | 
			
		||||
    feed_command('set bs=2')
 | 
			
		||||
    feed('gR0<C-d> 1<cr>')
 | 
			
		||||
    feed('A<cr>')
 | 
			
		||||
    feed('BCDEFGHIJ<cr>')
 | 
			
		||||
    feed('<tab>KL<cr>')
 | 
			
		||||
    feed('MNO<cr>')
 | 
			
		||||
    feed('PQR<esc>G')
 | 
			
		||||
    execute('ka')
 | 
			
		||||
    feed_command('ka')
 | 
			
		||||
    feed('o0<C-d><cr>')
 | 
			
		||||
    feed('abcdefghi<cr>')
 | 
			
		||||
    feed('jk<tab>lmn<cr>')
 | 
			
		||||
 
 | 
			
		||||
@@ -5,14 +5,14 @@ local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local nvim, eq = helpers.meths, helpers.eq
 | 
			
		||||
local insert, feed = helpers.insert, helpers.feed
 | 
			
		||||
local clear, expect = helpers.clear, helpers.expect
 | 
			
		||||
local execute = helpers.execute
 | 
			
		||||
local feed_command = helpers.feed_command
 | 
			
		||||
 | 
			
		||||
describe('Visual block mode', function()
 | 
			
		||||
 | 
			
		||||
  before_each(function()
 | 
			
		||||
    clear()
 | 
			
		||||
 | 
			
		||||
    execute('set ts&vi sw&vi sts&vi noet') -- Vim compatible
 | 
			
		||||
    feed_command('set ts&vi sw&vi sts&vi noet') -- Vim compatible
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('should shift, insert, replace and change a block', function()
 | 
			
		||||
@@ -55,9 +55,9 @@ describe('Visual block mode', function()
 | 
			
		||||
      cccc
 | 
			
		||||
      dddd]])
 | 
			
		||||
 | 
			
		||||
    execute('/^aa')
 | 
			
		||||
    feed_command('/^aa')
 | 
			
		||||
    feed('l<C-v>jjjlllI<Right><Right>  <ESC>')
 | 
			
		||||
    execute('/xaaa$')
 | 
			
		||||
    feed_command('/xaaa$')
 | 
			
		||||
    feed('<C-v>jjjI<lt>><Left>p<ESC>')
 | 
			
		||||
 | 
			
		||||
    expect([[
 | 
			
		||||
@@ -84,13 +84,13 @@ describe('Visual block mode', function()
 | 
			
		||||
      4567]])
 | 
			
		||||
 | 
			
		||||
    -- Test for Visual block was created with the last <C-v>$.
 | 
			
		||||
    execute('/^A23$/')
 | 
			
		||||
    feed_command('/^A23$/')
 | 
			
		||||
    feed('l<C-v>j$Aab<ESC>')
 | 
			
		||||
    -- Test for Visual block was created with the middle <C-v>$ (1).
 | 
			
		||||
    execute('/^B23$/')
 | 
			
		||||
    feed_command('/^B23$/')
 | 
			
		||||
    feed('l<C-v>j$hAab<ESC>')
 | 
			
		||||
    -- Test for Visual block was created with the middle <C-v>$ (2).
 | 
			
		||||
    execute('/^C23$/')
 | 
			
		||||
    feed_command('/^C23$/')
 | 
			
		||||
    feed('l<C-v>j$hhAab<ESC>')
 | 
			
		||||
 | 
			
		||||
    expect([[
 | 
			
		||||
@@ -112,8 +112,8 @@ describe('Visual block mode', function()
 | 
			
		||||
      ]])
 | 
			
		||||
 | 
			
		||||
    -- Test for Visual block insert when virtualedit=all and utf-8 encoding.
 | 
			
		||||
    execute('set ve=all')
 | 
			
		||||
    execute('/\t\tline')
 | 
			
		||||
    feed_command('set ve=all')
 | 
			
		||||
    feed_command('/\t\tline')
 | 
			
		||||
    feed('07l<C-v>jjIx<ESC>')
 | 
			
		||||
 | 
			
		||||
    expect([[
 | 
			
		||||
@@ -199,10 +199,10 @@ describe('Visual block mode', function()
 | 
			
		||||
      98765]])
 | 
			
		||||
 | 
			
		||||
    -- Test cursor position. When virtualedit=block and Visual block mode and $gj.
 | 
			
		||||
    execute('set ve=block')
 | 
			
		||||
    feed_command('set ve=block')
 | 
			
		||||
    feed('G2l')
 | 
			
		||||
    feed('2k<C-v>$gj<ESC>')
 | 
			
		||||
    execute([[let cpos=getpos("'>")]])
 | 
			
		||||
    feed_command([[let cpos=getpos("'>")]])
 | 
			
		||||
    local cpos = nvim.get_var('cpos')
 | 
			
		||||
    local expected = {
 | 
			
		||||
      col = 4,
 | 
			
		||||
@@ -223,7 +223,7 @@ describe('Visual block mode', function()
 | 
			
		||||
      #define BO_CRSR	    0x0004]])
 | 
			
		||||
 | 
			
		||||
    -- Block_insert when replacing spaces in front of the block with tabs.
 | 
			
		||||
    execute('set ts=8 sts=4 sw=4')
 | 
			
		||||
    feed_command('set ts=8 sts=4 sw=4')
 | 
			
		||||
    feed('ggf0<C-v>2jI<TAB><ESC>')
 | 
			
		||||
 | 
			
		||||
    expect([[
 | 
			
		||||
 
 | 
			
		||||
@@ -1,8 +1,10 @@
 | 
			
		||||
-- Test for writing and reading a file of over 100 Kbyte
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
 | 
			
		||||
local clear, feed, insert = helpers.clear, helpers.feed, helpers.insert
 | 
			
		||||
local execute, expect = helpers.execute, helpers.expect
 | 
			
		||||
local command, expect = helpers.command, helpers.expect
 | 
			
		||||
local wait = helpers.wait
 | 
			
		||||
 | 
			
		||||
describe('writing and reading a file of over 100 Kbyte', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
@@ -16,17 +18,18 @@ describe('writing and reading a file of over 100 Kbyte', function()
 | 
			
		||||
      This is the end]])
 | 
			
		||||
 | 
			
		||||
    feed('kY3000p2GY3000p')
 | 
			
		||||
    wait()
 | 
			
		||||
 | 
			
		||||
    execute('w! test.out')
 | 
			
		||||
    execute('%d')
 | 
			
		||||
    execute('e! test.out')
 | 
			
		||||
    execute('yank A')
 | 
			
		||||
    execute('3003yank A')
 | 
			
		||||
    execute('6005yank A')
 | 
			
		||||
    execute('%d')
 | 
			
		||||
    execute('0put a')
 | 
			
		||||
    execute('$d')
 | 
			
		||||
    execute('w!')
 | 
			
		||||
    command('w! test.out')
 | 
			
		||||
    command('%d')
 | 
			
		||||
    command('e! test.out')
 | 
			
		||||
    command('yank A')
 | 
			
		||||
    command('3003yank A')
 | 
			
		||||
    command('6005yank A')
 | 
			
		||||
    command('%d')
 | 
			
		||||
    command('0put a')
 | 
			
		||||
    command('$d')
 | 
			
		||||
    command('w!')
 | 
			
		||||
 | 
			
		||||
    expect([[
 | 
			
		||||
      This is the start
 | 
			
		||||
 
 | 
			
		||||
@@ -1,9 +1,8 @@
 | 
			
		||||
-- vim: set foldmethod=marker foldmarker=[[,]] :
 | 
			
		||||
-- Tests for regexp with various magic settings.
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear, feed, insert = helpers.clear, helpers.feed, helpers.insert
 | 
			
		||||
local execute, expect = helpers.execute, helpers.expect
 | 
			
		||||
local feed_command, expect = helpers.feed_command, helpers.expect
 | 
			
		||||
 | 
			
		||||
describe('regexp with magic settings', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
@@ -21,27 +20,27 @@ describe('regexp with magic settings', function()
 | 
			
		||||
      9 foobar
 | 
			
		||||
      ]])
 | 
			
		||||
 | 
			
		||||
    execute('/^1')
 | 
			
		||||
    execute([[/a*b\{2}c\+/e]])
 | 
			
		||||
    feed_command('/^1')
 | 
			
		||||
    feed_command([[/a*b\{2}c\+/e]])
 | 
			
		||||
    feed([[x/\Md\*e\{2}f\+/e<cr>]])
 | 
			
		||||
    feed('x:set nomagic<cr>')
 | 
			
		||||
    execute([[/g\*h\{2}i\+/e]])
 | 
			
		||||
    feed_command([[/g\*h\{2}i\+/e]])
 | 
			
		||||
    feed([[x/\mj*k\{2}l\+/e<cr>]])
 | 
			
		||||
    feed([[x/\vm*n{2}o+/e<cr>]])
 | 
			
		||||
    feed([[x/\V^aa$<cr>]])
 | 
			
		||||
    feed('x:set magic<cr>')
 | 
			
		||||
    execute([[/\v(a)(b)\2\1\1/e]])
 | 
			
		||||
    feed_command([[/\v(a)(b)\2\1\1/e]])
 | 
			
		||||
    feed([[x/\V[ab]\(\[xy]\)\1<cr>]])
 | 
			
		||||
    feed('x:$<cr>')
 | 
			
		||||
    execute('set undolevels=100')
 | 
			
		||||
    feed_command('set undolevels=100')
 | 
			
		||||
    feed('dv?bar?<cr>')
 | 
			
		||||
    feed('Yup:<cr>')
 | 
			
		||||
    execute('?^1?,$yank A')
 | 
			
		||||
    feed_command('?^1?,$yank A')
 | 
			
		||||
 | 
			
		||||
    -- Put @a and clean empty line
 | 
			
		||||
    execute('%d')
 | 
			
		||||
    execute('0put a')
 | 
			
		||||
    execute('$d')
 | 
			
		||||
    feed_command('%d')
 | 
			
		||||
    feed_command('0put a')
 | 
			
		||||
    feed_command('$d')
 | 
			
		||||
 | 
			
		||||
    -- Assert buffer contents.
 | 
			
		||||
    expect([[
 | 
			
		||||
 
 | 
			
		||||
@@ -5,7 +5,7 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local feed, insert = helpers.feed, helpers.insert
 | 
			
		||||
local clear, execute, expect = helpers.clear, helpers.execute, helpers.expect
 | 
			
		||||
local clear, feed_command, expect = helpers.clear, helpers.feed_command, helpers.expect
 | 
			
		||||
 | 
			
		||||
-- Runs the test protocol with the given 'regexpengine' setting. In the old test
 | 
			
		||||
-- suite the test protocol was duplicated in test44 and test99, the only
 | 
			
		||||
@@ -32,19 +32,19 @@ local function run_test_with_regexpengine(regexpengine)
 | 
			
		||||
    k combinations
 | 
			
		||||
    l ä ö ü ᾱ̆́]])
 | 
			
		||||
 | 
			
		||||
  execute('set re=' .. regexpengine)
 | 
			
		||||
  feed_command('set re=' .. regexpengine)
 | 
			
		||||
 | 
			
		||||
  -- Lines 1-8. Exercise regexp search with various magic settings. On each
 | 
			
		||||
  -- line the character on which the cursor is expected to land is deleted.
 | 
			
		||||
  feed('/^1<cr>')
 | 
			
		||||
  feed([[/a*b\{2}c\+/e<cr>x]])
 | 
			
		||||
  feed([[/\Md\*e\{2}f\+/e<cr>x]])
 | 
			
		||||
  execute('set nomagic')
 | 
			
		||||
  feed_command('set nomagic')
 | 
			
		||||
  feed([[/g\*h\{2}i\+/e<cr>x]])
 | 
			
		||||
  feed([[/\mj*k\{2}l\+/e<cr>x]])
 | 
			
		||||
  feed([[/\vm*n{2}o+/e<cr>x]])
 | 
			
		||||
  feed([[/\V^aa$<cr>x]])
 | 
			
		||||
  execute('set magic')
 | 
			
		||||
  feed_command('set magic')
 | 
			
		||||
  feed([[/\v(a)(b)\2\1\1/e<cr>x]])
 | 
			
		||||
  feed([[/\V[ab]\(\[xy]\)\1<cr>x]])
 | 
			
		||||
 | 
			
		||||
@@ -57,7 +57,7 @@ local function run_test_with_regexpengine(regexpengine)
 | 
			
		||||
  -- Line b. Find word by change of word class.
 | 
			
		||||
  -- (The "<" character in this test step seemed to confuse our "feed" test
 | 
			
		||||
  -- helper, which is why we've resorted to "execute" here.)
 | 
			
		||||
  execute([[/ち\<カヨ\>は]])
 | 
			
		||||
  feed_command([[/ち\<カヨ\>は]])
 | 
			
		||||
  feed('x')
 | 
			
		||||
 | 
			
		||||
  -- Lines c-i. Test \%u, [\u], and friends.
 | 
			
		||||
@@ -73,28 +73,28 @@ local function run_test_with_regexpengine(regexpengine)
 | 
			
		||||
 | 
			
		||||
  -- Line k. Test substitution with combining characters by executing register
 | 
			
		||||
  -- contents.
 | 
			
		||||
  execute([[let @w=':%s#comb[i]nations#œ̄ṣ́m̥̄ᾱ̆́#g']])
 | 
			
		||||
  execute('@w')
 | 
			
		||||
  feed_command([[let @w=':%s#comb[i]nations#œ̄ṣ́m̥̄ᾱ̆́#g']])
 | 
			
		||||
  feed_command('@w')
 | 
			
		||||
 | 
			
		||||
  -- Line l. Ex command ":s/ \?/ /g" should NOT split multi-byte characters
 | 
			
		||||
  -- into bytes (fixed by vim-7.3.192).
 | 
			
		||||
  execute([[/^l]])
 | 
			
		||||
  execute([[s/ \?/ /g]])
 | 
			
		||||
  feed_command([[/^l]])
 | 
			
		||||
  feed_command([[s/ \?/ /g]])
 | 
			
		||||
 | 
			
		||||
  -- Additional tests. Test matchstr() with multi-byte characters.
 | 
			
		||||
  feed('G')
 | 
			
		||||
  execute([[put =matchstr(\"אבגד\", \".\", 0, 2)]])   -- ב
 | 
			
		||||
  execute([[put =matchstr(\"אבגד\", \"..\", 0, 2)]])  -- בג
 | 
			
		||||
  execute([[put =matchstr(\"אבגד\", \".\", 0, 0)]])   -- א
 | 
			
		||||
  execute([[put =matchstr(\"אבגד\", \".\", 4, -1)]])  -- ג
 | 
			
		||||
  feed_command([[put =matchstr(\"אבגד\", \".\", 0, 2)]])   -- ב
 | 
			
		||||
  feed_command([[put =matchstr(\"אבגד\", \"..\", 0, 2)]])  -- בג
 | 
			
		||||
  feed_command([[put =matchstr(\"אבגד\", \".\", 0, 0)]])   -- א
 | 
			
		||||
  feed_command([[put =matchstr(\"אבגד\", \".\", 4, -1)]])  -- ג
 | 
			
		||||
 | 
			
		||||
  -- Test that a search with "/e" offset wraps around at the end of the buffer.
 | 
			
		||||
  execute('new')
 | 
			
		||||
  execute([[$put =['dog(a', 'cat('] ]])
 | 
			
		||||
  feed_command('new')
 | 
			
		||||
  feed_command([[$put =['dog(a', 'cat('] ]])
 | 
			
		||||
  feed('/(/e+<cr>')
 | 
			
		||||
  feed('"ayn')
 | 
			
		||||
  execute('bd!')
 | 
			
		||||
  execute([[$put ='']])
 | 
			
		||||
  feed_command('bd!')
 | 
			
		||||
  feed_command([[$put ='']])
 | 
			
		||||
  feed('G"ap')
 | 
			
		||||
 | 
			
		||||
  -- Assert buffer contents.
 | 
			
		||||
 
 | 
			
		||||
@@ -2,8 +2,8 @@
 | 
			
		||||
local Screen = require('test.functional.ui.screen')
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local feed, insert, execute, expect_any =
 | 
			
		||||
  helpers.feed, helpers.insert, helpers.execute, helpers.expect_any
 | 
			
		||||
local feed, insert, feed_command, expect_any =
 | 
			
		||||
  helpers.feed, helpers.insert, helpers.feed_command, helpers.expect_any
 | 
			
		||||
 | 
			
		||||
describe('folding', function()
 | 
			
		||||
  local screen
 | 
			
		||||
@@ -28,15 +28,15 @@ describe('folding', function()
 | 
			
		||||
 | 
			
		||||
    -- Basic test if a fold can be created, opened, moving to the end and
 | 
			
		||||
    -- closed.
 | 
			
		||||
    execute('1')
 | 
			
		||||
    feed_command('1')
 | 
			
		||||
    feed('zf2j')
 | 
			
		||||
    execute('call append("$", "manual " . getline(foldclosed(".")))')
 | 
			
		||||
    feed_command('call append("$", "manual " . getline(foldclosed(".")))')
 | 
			
		||||
    feed('zo')
 | 
			
		||||
    execute('call append("$", foldclosed("."))')
 | 
			
		||||
    feed_command('call append("$", foldclosed("."))')
 | 
			
		||||
    feed(']z')
 | 
			
		||||
    execute('call append("$", getline("."))')
 | 
			
		||||
    feed_command('call append("$", getline("."))')
 | 
			
		||||
    feed('zc')
 | 
			
		||||
    execute('call append("$", getline(foldclosed(".")))')
 | 
			
		||||
    feed_command('call append("$", getline(foldclosed(".")))')
 | 
			
		||||
 | 
			
		||||
    expect_any([[
 | 
			
		||||
      manual 1 aa
 | 
			
		||||
@@ -52,15 +52,15 @@ describe('folding', function()
 | 
			
		||||
      ee {{{ }}}
 | 
			
		||||
      ff }}}
 | 
			
		||||
    ]])
 | 
			
		||||
    execute('set fdm=marker fdl=1')
 | 
			
		||||
    execute('2')
 | 
			
		||||
    execute('call append("$", "line 2 foldlevel=" . foldlevel("."))')
 | 
			
		||||
    feed_command('set fdm=marker fdl=1')
 | 
			
		||||
    feed_command('2')
 | 
			
		||||
    feed_command('call append("$", "line 2 foldlevel=" . foldlevel("."))')
 | 
			
		||||
    feed('[z')
 | 
			
		||||
    execute('call append("$", foldlevel("."))')
 | 
			
		||||
    feed_command('call append("$", foldlevel("."))')
 | 
			
		||||
    feed('jo{{ <esc>r{jj') -- writes '{{{' and moves 2 lines bot
 | 
			
		||||
    execute('call append("$", foldlevel("."))')
 | 
			
		||||
    feed_command('call append("$", foldlevel("."))')
 | 
			
		||||
    feed('kYpj')
 | 
			
		||||
    execute('call append("$", foldlevel("."))')
 | 
			
		||||
    feed_command('call append("$", foldlevel("."))')
 | 
			
		||||
 | 
			
		||||
    helpers.wait()
 | 
			
		||||
    screen:expect([[
 | 
			
		||||
@@ -80,15 +80,15 @@ describe('folding', function()
 | 
			
		||||
 | 
			
		||||
  it("foldmethod=indent", function()
 | 
			
		||||
    screen:try_resize(20, 8)
 | 
			
		||||
    execute('set fdm=indent sw=2')
 | 
			
		||||
    feed_command('set fdm=indent sw=2')
 | 
			
		||||
    insert([[
 | 
			
		||||
    aa
 | 
			
		||||
      bb
 | 
			
		||||
        cc
 | 
			
		||||
    last
 | 
			
		||||
    ]])
 | 
			
		||||
    execute('call append("$", "foldlevel line3=" . foldlevel(3))')
 | 
			
		||||
    execute('call append("$", foldlevel(2))')
 | 
			
		||||
    feed_command('call append("$", "foldlevel line3=" . foldlevel(3))')
 | 
			
		||||
    feed_command('call append("$", foldlevel(2))')
 | 
			
		||||
    feed('zR')
 | 
			
		||||
 | 
			
		||||
    helpers.wait()
 | 
			
		||||
@@ -119,23 +119,23 @@ describe('folding', function()
 | 
			
		||||
      a jj
 | 
			
		||||
      b kk
 | 
			
		||||
      last]])
 | 
			
		||||
    execute('set fdm=syntax fdl=0')
 | 
			
		||||
    execute('syn region Hup start="dd" end="ii" fold contains=Fd1,Fd2,Fd3')
 | 
			
		||||
    execute('syn region Fd1 start="ee" end="ff" fold contained')
 | 
			
		||||
    execute('syn region Fd2 start="gg" end="hh" fold contained')
 | 
			
		||||
    execute('syn region Fd3 start="commentstart" end="commentend" fold contained')
 | 
			
		||||
    feed_command('set fdm=syntax fdl=0')
 | 
			
		||||
    feed_command('syn region Hup start="dd" end="ii" fold contains=Fd1,Fd2,Fd3')
 | 
			
		||||
    feed_command('syn region Fd1 start="ee" end="ff" fold contained')
 | 
			
		||||
    feed_command('syn region Fd2 start="gg" end="hh" fold contained')
 | 
			
		||||
    feed_command('syn region Fd3 start="commentstart" end="commentend" fold contained')
 | 
			
		||||
    feed('Gzk')
 | 
			
		||||
    execute('call append("$", "folding " . getline("."))')
 | 
			
		||||
    feed_command('call append("$", "folding " . getline("."))')
 | 
			
		||||
    feed('k')
 | 
			
		||||
    execute('call append("$", getline("."))')
 | 
			
		||||
    feed_command('call append("$", getline("."))')
 | 
			
		||||
    feed('jAcommentstart  <esc>Acommentend<esc>')
 | 
			
		||||
    execute('set fdl=1')
 | 
			
		||||
    feed_command('set fdl=1')
 | 
			
		||||
    feed('3j')
 | 
			
		||||
    execute('call append("$", getline("."))')
 | 
			
		||||
    execute('set fdl=0')
 | 
			
		||||
    feed_command('call append("$", getline("."))')
 | 
			
		||||
    feed_command('set fdl=0')
 | 
			
		||||
    feed('zO<C-L>j') -- <C-L> redraws screen
 | 
			
		||||
    execute('call append("$", getline("."))')
 | 
			
		||||
    execute('set fdl=0')
 | 
			
		||||
    feed_command('call append("$", getline("."))')
 | 
			
		||||
    feed_command('set fdl=0')
 | 
			
		||||
    expect_any([[
 | 
			
		||||
      folding 9 ii
 | 
			
		||||
      3 cc
 | 
			
		||||
@@ -158,7 +158,7 @@ describe('folding', function()
 | 
			
		||||
      b kk
 | 
			
		||||
      last ]])
 | 
			
		||||
 | 
			
		||||
    execute([[
 | 
			
		||||
    feed_command([[
 | 
			
		||||
    fun Flvl()
 | 
			
		||||
     let l = getline(v:lnum)
 | 
			
		||||
     if l =~ "bb$"
 | 
			
		||||
@@ -173,15 +173,15 @@ describe('folding', function()
 | 
			
		||||
     return "="
 | 
			
		||||
    endfun
 | 
			
		||||
    ]])
 | 
			
		||||
    execute('set fdm=expr fde=Flvl()')
 | 
			
		||||
    execute('/bb$')
 | 
			
		||||
    execute('call append("$", "expr " . foldlevel("."))')
 | 
			
		||||
    execute('/hh$')
 | 
			
		||||
    execute('call append("$", foldlevel("."))')
 | 
			
		||||
    execute('/ii$')
 | 
			
		||||
    execute('call append("$", foldlevel("."))')
 | 
			
		||||
    execute('/kk$')
 | 
			
		||||
    execute('call append("$", foldlevel("."))')
 | 
			
		||||
    feed_command('set fdm=expr fde=Flvl()')
 | 
			
		||||
    feed_command('/bb$')
 | 
			
		||||
    feed_command('call append("$", "expr " . foldlevel("."))')
 | 
			
		||||
    feed_command('/hh$')
 | 
			
		||||
    feed_command('call append("$", foldlevel("."))')
 | 
			
		||||
    feed_command('/ii$')
 | 
			
		||||
    feed_command('call append("$", foldlevel("."))')
 | 
			
		||||
    feed_command('/kk$')
 | 
			
		||||
    feed_command('call append("$", foldlevel("."))')
 | 
			
		||||
 | 
			
		||||
    expect_any([[
 | 
			
		||||
      expr 2
 | 
			
		||||
@@ -199,11 +199,11 @@ describe('folding', function()
 | 
			
		||||
      	Test fdm=indent START
 | 
			
		||||
      	line3
 | 
			
		||||
      	line4]])
 | 
			
		||||
    execute('set noai nosta ')
 | 
			
		||||
    execute('set fdm=indent')
 | 
			
		||||
    execute('1m1')
 | 
			
		||||
    feed_command('set noai nosta ')
 | 
			
		||||
    feed_command('set fdm=indent')
 | 
			
		||||
    feed_command('1m1')
 | 
			
		||||
    feed('2jzc')
 | 
			
		||||
    execute('m0')
 | 
			
		||||
    feed_command('m0')
 | 
			
		||||
    feed('zR')
 | 
			
		||||
 | 
			
		||||
    expect_any([[
 | 
			
		||||
 
 | 
			
		||||
@@ -1,10 +1,9 @@
 | 
			
		||||
-- vim: set foldmethod=marker foldmarker=[[,]] :
 | 
			
		||||
-- Tests for ":highlight".
 | 
			
		||||
 | 
			
		||||
local Screen = require('test.functional.ui.screen')
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear, feed = helpers.clear, helpers.feed
 | 
			
		||||
local execute, expect = helpers.execute, helpers.expect
 | 
			
		||||
local command, expect = helpers.command, helpers.expect
 | 
			
		||||
local wait = helpers.wait
 | 
			
		||||
 | 
			
		||||
if helpers.pending_win32(pending) then return end
 | 
			
		||||
@@ -16,7 +15,7 @@ describe(':highlight', function()
 | 
			
		||||
    local screen = Screen.new(35, 10)
 | 
			
		||||
    screen:attach()
 | 
			
		||||
    -- Basic test if ":highlight" doesn't crash
 | 
			
		||||
    execute('set more', 'highlight')
 | 
			
		||||
    command('set more', 'highlight')
 | 
			
		||||
    -- FIXME(tarruda): We need to be sure the prompt is displayed before
 | 
			
		||||
    -- continuing, or risk a race condition where some of the following input
 | 
			
		||||
    -- is discarded resulting in test failure
 | 
			
		||||
@@ -34,38 +33,38 @@ describe(':highlight', function()
 | 
			
		||||
    ]])
 | 
			
		||||
    feed('q')
 | 
			
		||||
    wait() -- wait until we're back to normal
 | 
			
		||||
    execute('hi Search')
 | 
			
		||||
    command('hi Search')
 | 
			
		||||
 | 
			
		||||
    -- Test setting colors.
 | 
			
		||||
    -- Test clearing one color and all doesn't generate error or warning
 | 
			
		||||
    execute('hi NewGroup cterm=italic ctermfg=DarkBlue ctermbg=Grey gui=NONE guifg=#00ff00 guibg=Cyan')
 | 
			
		||||
    execute('hi Group2 cterm=NONE')
 | 
			
		||||
    execute('hi Group3 cterm=bold')
 | 
			
		||||
    execute('redir! @a')
 | 
			
		||||
    execute('hi NewGroup')
 | 
			
		||||
    execute('hi Group2')
 | 
			
		||||
    execute('hi Group3')
 | 
			
		||||
    execute('hi clear NewGroup')
 | 
			
		||||
    execute('hi NewGroup')
 | 
			
		||||
    execute('hi Group2')
 | 
			
		||||
    execute('hi Group2 NONE')
 | 
			
		||||
    execute('hi Group2')
 | 
			
		||||
    execute('hi clear')
 | 
			
		||||
    execute('hi Group3')
 | 
			
		||||
    execute([[hi Crash cterm='asdf]])
 | 
			
		||||
    execute('redir END')
 | 
			
		||||
    command('hi NewGroup cterm=italic ctermfg=DarkBlue ctermbg=Grey gui=NONE guifg=#00ff00 guibg=Cyan')
 | 
			
		||||
    command('hi Group2 cterm=NONE')
 | 
			
		||||
    command('hi Group3 cterm=bold')
 | 
			
		||||
    command('redir! @a')
 | 
			
		||||
    command('hi NewGroup')
 | 
			
		||||
    command('hi Group2')
 | 
			
		||||
    command('hi Group3')
 | 
			
		||||
    command('hi clear NewGroup')
 | 
			
		||||
    command('hi NewGroup')
 | 
			
		||||
    command('hi Group2')
 | 
			
		||||
    command('hi Group2 NONE')
 | 
			
		||||
    command('hi Group2')
 | 
			
		||||
    command('hi clear')
 | 
			
		||||
    command('hi Group3')
 | 
			
		||||
    command([[hi Crash cterm='asdf]])
 | 
			
		||||
    command('redir END')
 | 
			
		||||
 | 
			
		||||
    -- Filter ctermfg and ctermbg, the numbers depend on the terminal
 | 
			
		||||
    execute('0put a')
 | 
			
		||||
    execute([[%s/ctermfg=\d*/ctermfg=2/]])
 | 
			
		||||
    execute([[%s/ctermbg=\d*/ctermbg=3/]])
 | 
			
		||||
    command('0put a')
 | 
			
		||||
    command([[%s/ctermfg=\d*/ctermfg=2/]])
 | 
			
		||||
    command([[%s/ctermbg=\d*/ctermbg=3/]])
 | 
			
		||||
 | 
			
		||||
    -- Filter out possibly translated error message
 | 
			
		||||
    execute('%s/E475: [^:]*:/E475:/')
 | 
			
		||||
    command('%s/E475: [^:]*:/E475:/')
 | 
			
		||||
 | 
			
		||||
    -- Fix the fileformat
 | 
			
		||||
    execute('set ff&')
 | 
			
		||||
    execute('$d')
 | 
			
		||||
    command('set ff&')
 | 
			
		||||
    command('$d')
 | 
			
		||||
 | 
			
		||||
    -- Assert buffer contents.
 | 
			
		||||
    expect([[
 | 
			
		||||
 
 | 
			
		||||
@@ -2,7 +2,7 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local feed, source = helpers.feed, helpers.source
 | 
			
		||||
local clear, execute, expect = helpers.clear, helpers.execute, helpers.expect
 | 
			
		||||
local clear, feed_command, expect = helpers.clear, helpers.feed_command, helpers.expect
 | 
			
		||||
 | 
			
		||||
describe('list and dictionary types', function()
 | 
			
		||||
  before_each(clear)
 | 
			
		||||
@@ -142,40 +142,40 @@ describe('list and dictionary types', function()
 | 
			
		||||
 | 
			
		||||
  it("removing items out of range: silently skip items that don't exist", function()
 | 
			
		||||
    -- We can not use source() here as we want to ignore all errors.
 | 
			
		||||
    execute('lang C')
 | 
			
		||||
    execute('let l = [0, 1, 2, 3]')
 | 
			
		||||
    execute('unlet l[2:1]')
 | 
			
		||||
    execute('$put =string(l)')
 | 
			
		||||
    execute('let l = [0, 1, 2, 3]')
 | 
			
		||||
    execute('unlet l[2:2]')
 | 
			
		||||
    execute('$put =string(l)')
 | 
			
		||||
    execute('let l = [0, 1, 2, 3]')
 | 
			
		||||
    execute('unlet l[2:3]')
 | 
			
		||||
    execute('$put =string(l)')
 | 
			
		||||
    execute('let l = [0, 1, 2, 3]')
 | 
			
		||||
    execute('unlet l[2:4]')
 | 
			
		||||
    execute('$put =string(l)')
 | 
			
		||||
    execute('let l = [0, 1, 2, 3]')
 | 
			
		||||
    execute('unlet l[2:5]')
 | 
			
		||||
    execute('$put =string(l)')
 | 
			
		||||
    execute('let l = [0, 1, 2, 3]')
 | 
			
		||||
    execute('unlet l[-1:2]')
 | 
			
		||||
    execute('$put =string(l)')
 | 
			
		||||
    execute('let l = [0, 1, 2, 3]')
 | 
			
		||||
    execute('unlet l[-2:2]')
 | 
			
		||||
    execute('$put =string(l)')
 | 
			
		||||
    execute('let l = [0, 1, 2, 3]')
 | 
			
		||||
    execute('unlet l[-3:2]')
 | 
			
		||||
    execute('$put =string(l)')
 | 
			
		||||
    execute('let l = [0, 1, 2, 3]')
 | 
			
		||||
    execute('unlet l[-4:2]')
 | 
			
		||||
    execute('$put =string(l)')
 | 
			
		||||
    execute('let l = [0, 1, 2, 3]')
 | 
			
		||||
    execute('unlet l[-5:2]')
 | 
			
		||||
    execute('$put =string(l)')
 | 
			
		||||
    execute('let l = [0, 1, 2, 3]')
 | 
			
		||||
    execute('unlet l[-6:2]')
 | 
			
		||||
    execute('$put =string(l)')
 | 
			
		||||
    feed_command('lang C')
 | 
			
		||||
    feed_command('let l = [0, 1, 2, 3]')
 | 
			
		||||
    feed_command('unlet l[2:1]')
 | 
			
		||||
    feed_command('$put =string(l)')
 | 
			
		||||
    feed_command('let l = [0, 1, 2, 3]')
 | 
			
		||||
    feed_command('unlet l[2:2]')
 | 
			
		||||
    feed_command('$put =string(l)')
 | 
			
		||||
    feed_command('let l = [0, 1, 2, 3]')
 | 
			
		||||
    feed_command('unlet l[2:3]')
 | 
			
		||||
    feed_command('$put =string(l)')
 | 
			
		||||
    feed_command('let l = [0, 1, 2, 3]')
 | 
			
		||||
    feed_command('unlet l[2:4]')
 | 
			
		||||
    feed_command('$put =string(l)')
 | 
			
		||||
    feed_command('let l = [0, 1, 2, 3]')
 | 
			
		||||
    feed_command('unlet l[2:5]')
 | 
			
		||||
    feed_command('$put =string(l)')
 | 
			
		||||
    feed_command('let l = [0, 1, 2, 3]')
 | 
			
		||||
    feed_command('unlet l[-1:2]')
 | 
			
		||||
    feed_command('$put =string(l)')
 | 
			
		||||
    feed_command('let l = [0, 1, 2, 3]')
 | 
			
		||||
    feed_command('unlet l[-2:2]')
 | 
			
		||||
    feed_command('$put =string(l)')
 | 
			
		||||
    feed_command('let l = [0, 1, 2, 3]')
 | 
			
		||||
    feed_command('unlet l[-3:2]')
 | 
			
		||||
    feed_command('$put =string(l)')
 | 
			
		||||
    feed_command('let l = [0, 1, 2, 3]')
 | 
			
		||||
    feed_command('unlet l[-4:2]')
 | 
			
		||||
    feed_command('$put =string(l)')
 | 
			
		||||
    feed_command('let l = [0, 1, 2, 3]')
 | 
			
		||||
    feed_command('unlet l[-5:2]')
 | 
			
		||||
    feed_command('$put =string(l)')
 | 
			
		||||
    feed_command('let l = [0, 1, 2, 3]')
 | 
			
		||||
    feed_command('unlet l[-6:2]')
 | 
			
		||||
    feed_command('$put =string(l)')
 | 
			
		||||
    expect([=[
 | 
			
		||||
 | 
			
		||||
      [0, 1, 2, 3]
 | 
			
		||||
@@ -676,7 +676,7 @@ describe('list and dictionary types', function()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('locked variables (part 2)', function()
 | 
			
		||||
    execute(
 | 
			
		||||
    feed_command(
 | 
			
		||||
      'let l = [1, 2, 3, 4]',
 | 
			
		||||
      'lockvar! l',
 | 
			
		||||
      '$put =string(l)',
 | 
			
		||||
@@ -749,7 +749,7 @@ describe('list and dictionary types', function()
 | 
			
		||||
          $put ='caught ' . v:exception
 | 
			
		||||
        endtry
 | 
			
		||||
      endfunction]])
 | 
			
		||||
    execute('call Test(1, 2, [3, 4], {5: 6})')
 | 
			
		||||
    feed_command('call Test(1, 2, [3, 4], {5: 6})')
 | 
			
		||||
    expect([=[
 | 
			
		||||
 | 
			
		||||
      caught a:000
 | 
			
		||||
@@ -897,18 +897,18 @@ describe('list and dictionary types', function()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('vim patch 7.3.637', function()
 | 
			
		||||
    execute('let a = "No error caught"')
 | 
			
		||||
    execute('try')
 | 
			
		||||
    execute('  foldopen')
 | 
			
		||||
    execute('catch')
 | 
			
		||||
    execute("  let a = matchstr(v:exception,'^[^ ]*')")
 | 
			
		||||
    execute('endtry')
 | 
			
		||||
    feed_command('let a = "No error caught"')
 | 
			
		||||
    feed_command('try')
 | 
			
		||||
    feed_command('  foldopen')
 | 
			
		||||
    feed_command('catch')
 | 
			
		||||
    feed_command("  let a = matchstr(v:exception,'^[^ ]*')")
 | 
			
		||||
    feed_command('endtry')
 | 
			
		||||
    feed('o<C-R>=a<CR><esc>')
 | 
			
		||||
    execute('lang C')
 | 
			
		||||
    execute('redir => a')
 | 
			
		||||
    feed_command('lang C')
 | 
			
		||||
    feed_command('redir => a')
 | 
			
		||||
    -- The test failes if this is not in one line.
 | 
			
		||||
    execute("try|foobar|catch|let a = matchstr(v:exception,'^[^ ]*')|endtry")
 | 
			
		||||
    execute('redir END')
 | 
			
		||||
    feed_command("try|foobar|catch|let a = matchstr(v:exception,'^[^ ]*')|endtry")
 | 
			
		||||
    feed_command('redir END')
 | 
			
		||||
    feed('o<C-R>=a<CR><esc>')
 | 
			
		||||
    expect([[
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
@@ -1,9 +1,11 @@
 | 
			
		||||
-- Tests for :sort command.
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local insert, execute, clear, expect, eq, eval, source = helpers.insert,
 | 
			
		||||
  helpers.execute, helpers.clear, helpers.expect, helpers.eq, helpers.eval,
 | 
			
		||||
  helpers.source
 | 
			
		||||
 | 
			
		||||
local insert, command, clear, expect, eq, eval, wait = helpers.insert,
 | 
			
		||||
  helpers.command, helpers.clear, helpers.expect, helpers.eq, helpers.eval,
 | 
			
		||||
  helpers.wait
 | 
			
		||||
local exc_exec = helpers.exc_exec
 | 
			
		||||
 | 
			
		||||
describe(':sort', function()
 | 
			
		||||
  local text = [[
 | 
			
		||||
@@ -26,7 +28,8 @@ describe(':sort', function()
 | 
			
		||||
 | 
			
		||||
  it('alphabetical', function()
 | 
			
		||||
    insert(text)
 | 
			
		||||
    execute('sort')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('sort')
 | 
			
		||||
    expect([[
 | 
			
		||||
 | 
			
		||||
       123b
 | 
			
		||||
@@ -65,7 +68,8 @@ describe(':sort', function()
 | 
			
		||||
      b321
 | 
			
		||||
      b321b
 | 
			
		||||
      ]])
 | 
			
		||||
    execute('sort n')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('sort n')
 | 
			
		||||
    expect([[
 | 
			
		||||
      abc
 | 
			
		||||
      ab
 | 
			
		||||
@@ -89,7 +93,8 @@ describe(':sort', function()
 | 
			
		||||
 | 
			
		||||
  it('hexadecimal', function()
 | 
			
		||||
    insert(text)
 | 
			
		||||
    execute('sort x')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('sort x')
 | 
			
		||||
    expect([[
 | 
			
		||||
 | 
			
		||||
      a
 | 
			
		||||
@@ -110,7 +115,8 @@ describe(':sort', function()
 | 
			
		||||
 | 
			
		||||
  it('alphabetical, unique', function()
 | 
			
		||||
    insert(text)
 | 
			
		||||
    execute('sort u')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('sort u')
 | 
			
		||||
    expect([[
 | 
			
		||||
 | 
			
		||||
       123b
 | 
			
		||||
@@ -130,7 +136,8 @@ describe(':sort', function()
 | 
			
		||||
 | 
			
		||||
  it('alphabetical, reverse', function()
 | 
			
		||||
    insert(text)
 | 
			
		||||
    execute('sort!')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('sort!')
 | 
			
		||||
    expect([[
 | 
			
		||||
      c321d
 | 
			
		||||
      c123d
 | 
			
		||||
@@ -151,7 +158,8 @@ describe(':sort', function()
 | 
			
		||||
 | 
			
		||||
  it('numerical, reverse', function()
 | 
			
		||||
    insert(text)
 | 
			
		||||
    execute('sort! n')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('sort! n')
 | 
			
		||||
    expect([[
 | 
			
		||||
      b322b
 | 
			
		||||
      b321b
 | 
			
		||||
@@ -172,7 +180,8 @@ describe(':sort', function()
 | 
			
		||||
 | 
			
		||||
  it('unique, reverse', function()
 | 
			
		||||
    insert(text)
 | 
			
		||||
    execute('sort! u')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('sort! u')
 | 
			
		||||
    expect([[
 | 
			
		||||
      c321d
 | 
			
		||||
      c123d
 | 
			
		||||
@@ -192,7 +201,8 @@ describe(':sort', function()
 | 
			
		||||
 | 
			
		||||
  it('octal', function()
 | 
			
		||||
    insert(text)
 | 
			
		||||
    execute('sort o')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('sort o')
 | 
			
		||||
    expect([[
 | 
			
		||||
      abc
 | 
			
		||||
      ab
 | 
			
		||||
@@ -213,7 +223,8 @@ describe(':sort', function()
 | 
			
		||||
 | 
			
		||||
  it('reverse, hexadecimal', function()
 | 
			
		||||
    insert(text)
 | 
			
		||||
    execute('sort! x')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('sort! x')
 | 
			
		||||
    expect([[
 | 
			
		||||
      c321d
 | 
			
		||||
      c123d
 | 
			
		||||
@@ -234,7 +245,8 @@ describe(':sort', function()
 | 
			
		||||
 | 
			
		||||
  it('alphabetical, skip first character', function()
 | 
			
		||||
    insert(text)
 | 
			
		||||
    execute('sort/./')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('sort/./')
 | 
			
		||||
    expect([[
 | 
			
		||||
      a
 | 
			
		||||
 | 
			
		||||
@@ -255,7 +267,8 @@ describe(':sort', function()
 | 
			
		||||
 | 
			
		||||
  it('alphabetical, skip first 2 characters', function()
 | 
			
		||||
    insert(text)
 | 
			
		||||
    execute('sort/../')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('sort/../')
 | 
			
		||||
    expect([[
 | 
			
		||||
      ab
 | 
			
		||||
      a
 | 
			
		||||
@@ -276,7 +289,8 @@ describe(':sort', function()
 | 
			
		||||
 | 
			
		||||
  it('alphabetical, unique, skip first 2 characters', function()
 | 
			
		||||
    insert(text)
 | 
			
		||||
    execute('sort/../u')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('sort/../u')
 | 
			
		||||
    expect([[
 | 
			
		||||
      ab
 | 
			
		||||
      a
 | 
			
		||||
@@ -296,7 +310,8 @@ describe(':sort', function()
 | 
			
		||||
 | 
			
		||||
  it('numerical, skip first character', function()
 | 
			
		||||
    insert(text)
 | 
			
		||||
    execute('sort/./n')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('sort/./n')
 | 
			
		||||
    expect([[
 | 
			
		||||
      abc
 | 
			
		||||
      ab
 | 
			
		||||
@@ -317,7 +332,8 @@ describe(':sort', function()
 | 
			
		||||
 | 
			
		||||
  it('alphabetical, sort on first character', function()
 | 
			
		||||
    insert(text)
 | 
			
		||||
    execute('sort/./r')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('sort/./r')
 | 
			
		||||
    expect([[
 | 
			
		||||
 | 
			
		||||
       123b
 | 
			
		||||
@@ -338,7 +354,8 @@ describe(':sort', function()
 | 
			
		||||
 | 
			
		||||
  it('alphabetical, sort on first 2 characters', function()
 | 
			
		||||
    insert(text)
 | 
			
		||||
    execute('sort/../r')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('sort/../r')
 | 
			
		||||
    expect([[
 | 
			
		||||
      a
 | 
			
		||||
 | 
			
		||||
@@ -359,7 +376,8 @@ describe(':sort', function()
 | 
			
		||||
 | 
			
		||||
  it('numerical, sort on first character', function()
 | 
			
		||||
    insert(text)
 | 
			
		||||
    execute('sort/./rn')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('sort/./rn')
 | 
			
		||||
    expect([[
 | 
			
		||||
      abc
 | 
			
		||||
      ab
 | 
			
		||||
@@ -380,7 +398,8 @@ describe(':sort', function()
 | 
			
		||||
 | 
			
		||||
  it('alphabetical, skip past first digit', function()
 | 
			
		||||
    insert(text)
 | 
			
		||||
    execute([[sort/\d/]])
 | 
			
		||||
    wait()
 | 
			
		||||
    command([[sort/\d/]])
 | 
			
		||||
    expect([[
 | 
			
		||||
      abc
 | 
			
		||||
      ab
 | 
			
		||||
@@ -401,7 +420,8 @@ describe(':sort', function()
 | 
			
		||||
 | 
			
		||||
  it('alphabetical, sort on first digit', function()
 | 
			
		||||
    insert(text)
 | 
			
		||||
    execute([[sort/\d/r]])
 | 
			
		||||
    wait()
 | 
			
		||||
    command([[sort/\d/r]])
 | 
			
		||||
    expect([[
 | 
			
		||||
      abc
 | 
			
		||||
      ab
 | 
			
		||||
@@ -422,7 +442,8 @@ describe(':sort', function()
 | 
			
		||||
 | 
			
		||||
  it('numerical, skip past first digit', function()
 | 
			
		||||
    insert(text)
 | 
			
		||||
    execute([[sort/\d/n]])
 | 
			
		||||
    wait()
 | 
			
		||||
    command([[sort/\d/n]])
 | 
			
		||||
    expect([[
 | 
			
		||||
      abc
 | 
			
		||||
      ab
 | 
			
		||||
@@ -443,7 +464,8 @@ describe(':sort', function()
 | 
			
		||||
 | 
			
		||||
  it('numerical, sort on first digit', function()
 | 
			
		||||
    insert(text)
 | 
			
		||||
    execute([[sort/\d/rn]])
 | 
			
		||||
    wait()
 | 
			
		||||
    command([[sort/\d/rn]])
 | 
			
		||||
    expect([[
 | 
			
		||||
      abc
 | 
			
		||||
      ab
 | 
			
		||||
@@ -464,7 +486,8 @@ describe(':sort', function()
 | 
			
		||||
 | 
			
		||||
  it('alphabetical, skip past first 2 digits', function()
 | 
			
		||||
    insert(text)
 | 
			
		||||
    execute([[sort/\d\d/]])
 | 
			
		||||
    wait()
 | 
			
		||||
    command([[sort/\d\d/]])
 | 
			
		||||
    expect([[
 | 
			
		||||
      abc
 | 
			
		||||
      ab
 | 
			
		||||
@@ -485,7 +508,8 @@ describe(':sort', function()
 | 
			
		||||
 | 
			
		||||
  it('numerical, skip past first 2 digits', function()
 | 
			
		||||
    insert(text)
 | 
			
		||||
    execute([[sort/\d\d/n]])
 | 
			
		||||
    wait()
 | 
			
		||||
    command([[sort/\d\d/n]])
 | 
			
		||||
    expect([[
 | 
			
		||||
      abc
 | 
			
		||||
      ab
 | 
			
		||||
@@ -506,7 +530,8 @@ describe(':sort', function()
 | 
			
		||||
 | 
			
		||||
  it('hexadecimal, skip past first 2 digits', function()
 | 
			
		||||
    insert(text)
 | 
			
		||||
    execute([[sort/\d\d/x]])
 | 
			
		||||
    wait()
 | 
			
		||||
    command([[sort/\d\d/x]])
 | 
			
		||||
    expect([[
 | 
			
		||||
      abc
 | 
			
		||||
      ab
 | 
			
		||||
@@ -527,7 +552,8 @@ describe(':sort', function()
 | 
			
		||||
 | 
			
		||||
  it('alpha, on first 2 digits', function()
 | 
			
		||||
    insert(text)
 | 
			
		||||
    execute([[sort/\d\d/r]])
 | 
			
		||||
    wait()
 | 
			
		||||
    command([[sort/\d\d/r]])
 | 
			
		||||
    expect([[
 | 
			
		||||
      abc
 | 
			
		||||
      ab
 | 
			
		||||
@@ -548,7 +574,8 @@ describe(':sort', function()
 | 
			
		||||
 | 
			
		||||
  it('numeric, on first 2 digits', function()
 | 
			
		||||
    insert(text)
 | 
			
		||||
    execute([[sort/\d\d/rn]])
 | 
			
		||||
    wait()
 | 
			
		||||
    command([[sort/\d\d/rn]])
 | 
			
		||||
    expect([[
 | 
			
		||||
      abc
 | 
			
		||||
      ab
 | 
			
		||||
@@ -569,7 +596,8 @@ describe(':sort', function()
 | 
			
		||||
 | 
			
		||||
  it('hexadecimal, on first 2 digits', function()
 | 
			
		||||
    insert(text)
 | 
			
		||||
    execute([[sort/\d\d/rx]])
 | 
			
		||||
    wait()
 | 
			
		||||
    command([[sort/\d\d/rx]])
 | 
			
		||||
    expect([[
 | 
			
		||||
      abc
 | 
			
		||||
      ab
 | 
			
		||||
@@ -591,13 +619,7 @@ describe(':sort', function()
 | 
			
		||||
  it('fails with wrong arguments', function()
 | 
			
		||||
    insert(text)
 | 
			
		||||
    -- This should fail with "E474: Invalid argument".
 | 
			
		||||
    source([[
 | 
			
		||||
      try
 | 
			
		||||
	sort no
 | 
			
		||||
      catch
 | 
			
		||||
	let tmpvar = v:exception
 | 
			
		||||
      endtry]])
 | 
			
		||||
    eq('Vim(sort):E474: Invalid argument', eval('tmpvar'))
 | 
			
		||||
    eq('Vim(sort):E474: Invalid argument', exc_exec('sort no'))
 | 
			
		||||
    expect(text)
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
@@ -617,7 +639,8 @@ describe(':sort', function()
 | 
			
		||||
      0b100010
 | 
			
		||||
      0b100100
 | 
			
		||||
      0b100010]])
 | 
			
		||||
    execute([[sort b]])
 | 
			
		||||
    wait()
 | 
			
		||||
    command([[sort b]])
 | 
			
		||||
    expect([[
 | 
			
		||||
      0b000000
 | 
			
		||||
      0b001000
 | 
			
		||||
@@ -651,7 +674,8 @@ describe(':sort', function()
 | 
			
		||||
      0b101010
 | 
			
		||||
      0b000000
 | 
			
		||||
      b0b111000]])
 | 
			
		||||
    execute([[sort b]])
 | 
			
		||||
    wait()
 | 
			
		||||
    command([[sort b]])
 | 
			
		||||
    expect([[
 | 
			
		||||
      0b000000
 | 
			
		||||
      a0b001000
 | 
			
		||||
@@ -677,7 +701,8 @@ describe(':sort', function()
 | 
			
		||||
      1.15e-6
 | 
			
		||||
      -1.1e3
 | 
			
		||||
      -1.01e3]])
 | 
			
		||||
    execute([[sort f]])
 | 
			
		||||
    wait()
 | 
			
		||||
    command([[sort f]])
 | 
			
		||||
    expect([[
 | 
			
		||||
      -1.1e3
 | 
			
		||||
      -1.01e3
 | 
			
		||||
 
 | 
			
		||||
@@ -2,7 +2,7 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local feed, insert, source = helpers.feed, helpers.insert, helpers.source
 | 
			
		||||
local clear, execute, expect = helpers.clear, helpers.execute, helpers.expect
 | 
			
		||||
local clear, feed_command, expect = helpers.clear, helpers.feed_command, helpers.expect
 | 
			
		||||
local write_file, call = helpers.write_file, helpers.call
 | 
			
		||||
 | 
			
		||||
if helpers.pending_win32(pending) then return end
 | 
			
		||||
@@ -15,7 +15,7 @@ end
 | 
			
		||||
describe("spell checking with 'encoding' set to utf-8", function()
 | 
			
		||||
  setup(function()
 | 
			
		||||
    clear()
 | 
			
		||||
    execute("syntax off")
 | 
			
		||||
    feed_command("syntax off")
 | 
			
		||||
    write_latin1('Xtest1.aff',[[
 | 
			
		||||
      SET ISO8859-1
 | 
			
		||||
      TRY esianrtolcdugmphbyfvkwjkqxz-ëéèêïîäàâöüû'ESIANRTOLCDUGMPHBYFVKWJKQXZ
 | 
			
		||||
@@ -555,55 +555,55 @@ describe("spell checking with 'encoding' set to utf-8", function()
 | 
			
		||||
      elequint test elekwint test elekwent asdf
 | 
			
		||||
      ]])
 | 
			
		||||
    test_one(1, 1)
 | 
			
		||||
    execute([[$put =soundfold('goobledygoook')]])
 | 
			
		||||
    execute([[$put =soundfold('kóopërÿnôven')]])
 | 
			
		||||
    execute([[$put =soundfold('oeverloos gezwets edale')]])
 | 
			
		||||
    feed_command([[$put =soundfold('goobledygoook')]])
 | 
			
		||||
    feed_command([[$put =soundfold('kóopërÿnôven')]])
 | 
			
		||||
    feed_command([[$put =soundfold('oeverloos gezwets edale')]])
 | 
			
		||||
    -- And now with SAL instead of SOFO items; test automatic reloading.
 | 
			
		||||
    os.execute('cp -f Xtest-sal.aff Xtest.aff')
 | 
			
		||||
    execute('mkspell! Xtest Xtest')
 | 
			
		||||
    execute([[$put =soundfold('goobledygoook')]])
 | 
			
		||||
    execute([[$put =soundfold('kóopërÿnôven')]])
 | 
			
		||||
    execute([[$put =soundfold('oeverloos gezwets edale')]])
 | 
			
		||||
    feed_command('mkspell! Xtest Xtest')
 | 
			
		||||
    feed_command([[$put =soundfold('goobledygoook')]])
 | 
			
		||||
    feed_command([[$put =soundfold('kóopërÿnôven')]])
 | 
			
		||||
    feed_command([[$put =soundfold('oeverloos gezwets edale')]])
 | 
			
		||||
    -- Also use an addition file.
 | 
			
		||||
    execute('mkspell! Xtest.utf-8.add.spl Xtest.utf-8.add')
 | 
			
		||||
    execute('set spellfile=Xtest.utf-8.add')
 | 
			
		||||
    execute('/^test2:')
 | 
			
		||||
    feed_command('mkspell! Xtest.utf-8.add.spl Xtest.utf-8.add')
 | 
			
		||||
    feed_command('set spellfile=Xtest.utf-8.add')
 | 
			
		||||
    feed_command('/^test2:')
 | 
			
		||||
    feed(']s')
 | 
			
		||||
    execute('let [str, a] = spellbadword()')
 | 
			
		||||
    execute('$put =str')
 | 
			
		||||
    execute('set spl=Xtest_us.utf-8.spl')
 | 
			
		||||
    execute('/^test2:')
 | 
			
		||||
    feed_command('let [str, a] = spellbadword()')
 | 
			
		||||
    feed_command('$put =str')
 | 
			
		||||
    feed_command('set spl=Xtest_us.utf-8.spl')
 | 
			
		||||
    feed_command('/^test2:')
 | 
			
		||||
    feed(']smm')
 | 
			
		||||
    execute('let [str, a] = spellbadword()')
 | 
			
		||||
    execute('$put =str')
 | 
			
		||||
    feed_command('let [str, a] = spellbadword()')
 | 
			
		||||
    feed_command('$put =str')
 | 
			
		||||
    feed('`m]s')
 | 
			
		||||
    execute('let [str, a] = spellbadword()')
 | 
			
		||||
    execute('$put =str')
 | 
			
		||||
    execute('set spl=Xtest_gb.utf-8.spl')
 | 
			
		||||
    execute('/^test2:')
 | 
			
		||||
    feed_command('let [str, a] = spellbadword()')
 | 
			
		||||
    feed_command('$put =str')
 | 
			
		||||
    feed_command('set spl=Xtest_gb.utf-8.spl')
 | 
			
		||||
    feed_command('/^test2:')
 | 
			
		||||
    feed(']smm')
 | 
			
		||||
    execute('let [str, a] = spellbadword()')
 | 
			
		||||
    execute('$put =str')
 | 
			
		||||
    feed_command('let [str, a] = spellbadword()')
 | 
			
		||||
    feed_command('$put =str')
 | 
			
		||||
    feed('`m]s')
 | 
			
		||||
    execute('let [str, a] = spellbadword()')
 | 
			
		||||
    execute('$put =str')
 | 
			
		||||
    execute('set spl=Xtest_nz.utf-8.spl')
 | 
			
		||||
    execute('/^test2:')
 | 
			
		||||
    feed_command('let [str, a] = spellbadword()')
 | 
			
		||||
    feed_command('$put =str')
 | 
			
		||||
    feed_command('set spl=Xtest_nz.utf-8.spl')
 | 
			
		||||
    feed_command('/^test2:')
 | 
			
		||||
    feed(']smm')
 | 
			
		||||
    execute('let [str, a] = spellbadword()')
 | 
			
		||||
    execute('$put =str')
 | 
			
		||||
    feed_command('let [str, a] = spellbadword()')
 | 
			
		||||
    feed_command('$put =str')
 | 
			
		||||
    feed('`m]s')
 | 
			
		||||
    execute('let [str, a] = spellbadword()')
 | 
			
		||||
    execute('$put =str')
 | 
			
		||||
    execute('set spl=Xtest_ca.utf-8.spl')
 | 
			
		||||
    execute('/^test2:')
 | 
			
		||||
    feed_command('let [str, a] = spellbadword()')
 | 
			
		||||
    feed_command('$put =str')
 | 
			
		||||
    feed_command('set spl=Xtest_ca.utf-8.spl')
 | 
			
		||||
    feed_command('/^test2:')
 | 
			
		||||
    feed(']smm')
 | 
			
		||||
    execute('let [str, a] = spellbadword()')
 | 
			
		||||
    execute('$put =str')
 | 
			
		||||
    feed_command('let [str, a] = spellbadword()')
 | 
			
		||||
    feed_command('$put =str')
 | 
			
		||||
    feed('`m]s')
 | 
			
		||||
    execute('let [str, a] = spellbadword()')
 | 
			
		||||
    execute('$put =str')
 | 
			
		||||
    execute('1,/^test 1-1/-1d')
 | 
			
		||||
    feed_command('let [str, a] = spellbadword()')
 | 
			
		||||
    feed_command('$put =str')
 | 
			
		||||
    feed_command('1,/^test 1-1/-1d')
 | 
			
		||||
    expect([[
 | 
			
		||||
      test 1-1
 | 
			
		||||
      # file: Xtest.utf-8.spl
 | 
			
		||||
@@ -667,7 +667,7 @@ describe("spell checking with 'encoding' set to utf-8", function()
 | 
			
		||||
      ]])
 | 
			
		||||
    -- Postponed prefixes.
 | 
			
		||||
    test_one(2, 1)
 | 
			
		||||
    execute('1,/^test 2-1/-1d')
 | 
			
		||||
    feed_command('1,/^test 2-1/-1d')
 | 
			
		||||
    expect([=[
 | 
			
		||||
      test 2-1
 | 
			
		||||
      # file: Xtest.utf-8.spl
 | 
			
		||||
@@ -717,7 +717,7 @@ describe("spell checking with 'encoding' set to utf-8", function()
 | 
			
		||||
      badend
 | 
			
		||||
      ]])
 | 
			
		||||
    test_one(3, 3)
 | 
			
		||||
    execute('1,/^test 3-3/-1d')
 | 
			
		||||
    feed_command('1,/^test 3-3/-1d')
 | 
			
		||||
    expect([=[
 | 
			
		||||
      test 3-3
 | 
			
		||||
      # file: Xtest.utf-8.spl
 | 
			
		||||
@@ -770,7 +770,7 @@ describe("spell checking with 'encoding' set to utf-8", function()
 | 
			
		||||
      badend
 | 
			
		||||
      ]])
 | 
			
		||||
    test_one(4, 4)
 | 
			
		||||
    execute('1,/^test 4-4/-1d')
 | 
			
		||||
    feed_command('1,/^test 4-4/-1d')
 | 
			
		||||
    expect([=[
 | 
			
		||||
      test 4-4
 | 
			
		||||
      # file: Xtest.utf-8.spl
 | 
			
		||||
@@ -831,7 +831,7 @@ describe("spell checking with 'encoding' set to utf-8", function()
 | 
			
		||||
      badend
 | 
			
		||||
      ]])
 | 
			
		||||
    test_one(5, 5)
 | 
			
		||||
    execute('1,/^test 5-5/-1d')
 | 
			
		||||
    feed_command('1,/^test 5-5/-1d')
 | 
			
		||||
    expect([=[
 | 
			
		||||
      test 5-5
 | 
			
		||||
      # file: Xtest.utf-8.spl
 | 
			
		||||
@@ -878,7 +878,7 @@ describe("spell checking with 'encoding' set to utf-8", function()
 | 
			
		||||
      badend
 | 
			
		||||
      ]])
 | 
			
		||||
    test_one(6, 6)
 | 
			
		||||
    execute('1,/^test 6-6/-1d')
 | 
			
		||||
    feed_command('1,/^test 6-6/-1d')
 | 
			
		||||
    expect([=[
 | 
			
		||||
      test 6-6
 | 
			
		||||
      # file: Xtest.utf-8.spl
 | 
			
		||||
@@ -924,7 +924,7 @@ describe("spell checking with 'encoding' set to utf-8", function()
 | 
			
		||||
    -- Compound words.
 | 
			
		||||
    test_one(7, 7)
 | 
			
		||||
    -- Assert buffer contents.
 | 
			
		||||
    execute('1,/^test 7-7/-1d')
 | 
			
		||||
    feed_command('1,/^test 7-7/-1d')
 | 
			
		||||
    expect([=[
 | 
			
		||||
      test 7-7
 | 
			
		||||
      # file: Xtest.utf-8.spl
 | 
			
		||||
@@ -968,7 +968,7 @@ describe("spell checking with 'encoding' set to utf-8", function()
 | 
			
		||||
    -- NOSPLITSUGS
 | 
			
		||||
    test_one(8, 8)
 | 
			
		||||
    -- Assert buffer contents.
 | 
			
		||||
    execute('1,/^test 8-8/-1d')
 | 
			
		||||
    feed_command('1,/^test 8-8/-1d')
 | 
			
		||||
    expect([=[
 | 
			
		||||
      test 8-8
 | 
			
		||||
      # file: Xtest.utf-8.spl
 | 
			
		||||
@@ -992,7 +992,7 @@ describe("spell checking with 'encoding' set to utf-8", function()
 | 
			
		||||
    -- NOSPLITSUGS
 | 
			
		||||
    test_one(9, 9)
 | 
			
		||||
    -- Assert buffer contents.
 | 
			
		||||
    execute('1,/^test 9-9/-1d')
 | 
			
		||||
    feed_command('1,/^test 9-9/-1d')
 | 
			
		||||
    expect([=[
 | 
			
		||||
      test 9-9
 | 
			
		||||
      # file: Xtest.utf-8.spl
 | 
			
		||||
 
 | 
			
		||||
@@ -1,8 +1,8 @@
 | 
			
		||||
-- Tests for undo tree and :earlier and :later.
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
 | 
			
		||||
local feed_command = helpers.feed_command
 | 
			
		||||
local write_file = helpers.write_file
 | 
			
		||||
local execute = helpers.execute
 | 
			
		||||
local command = helpers.command
 | 
			
		||||
local source = helpers.source
 | 
			
		||||
local expect = helpers.expect
 | 
			
		||||
@@ -44,7 +44,7 @@ describe('undo tree:', function()
 | 
			
		||||
      -- function to allow multiple attempts.
 | 
			
		||||
      local function test_earlier_later()
 | 
			
		||||
        clear()
 | 
			
		||||
        execute('e Xtest')
 | 
			
		||||
        feed_command('e Xtest')
 | 
			
		||||
        -- Assert that no undo history is present.
 | 
			
		||||
        eq({}, eval('undotree().entries'))
 | 
			
		||||
        -- Delete three characters and undo.
 | 
			
		||||
@@ -88,13 +88,13 @@ describe('undo tree:', function()
 | 
			
		||||
        feed('Ab<esc>')
 | 
			
		||||
        feed('Ac<esc>')
 | 
			
		||||
        expect_line('123456abc')
 | 
			
		||||
        execute('earlier 1s')
 | 
			
		||||
        feed_command('earlier 1s')
 | 
			
		||||
        expect_line('123456')
 | 
			
		||||
        execute('earlier 3s')
 | 
			
		||||
        feed_command('earlier 3s')
 | 
			
		||||
        expect_line('123456789')
 | 
			
		||||
        execute('later 1s')
 | 
			
		||||
        feed_command('later 1s')
 | 
			
		||||
        expect_line('123456')
 | 
			
		||||
        execute('later 1h')
 | 
			
		||||
        feed_command('later 1h')
 | 
			
		||||
        expect_line('123456abc')
 | 
			
		||||
      end
 | 
			
		||||
 | 
			
		||||
@@ -103,28 +103,28 @@ describe('undo tree:', function()
 | 
			
		||||
 | 
			
		||||
    it('file-write specifications', function()
 | 
			
		||||
      feed('ione one one<esc>')
 | 
			
		||||
      execute('w Xtest')
 | 
			
		||||
      feed_command('w Xtest')
 | 
			
		||||
      feed('otwo<esc>')
 | 
			
		||||
      feed('otwo<esc>')
 | 
			
		||||
      execute('w')
 | 
			
		||||
      feed_command('w')
 | 
			
		||||
      feed('othree<esc>')
 | 
			
		||||
      execute('earlier 1f')
 | 
			
		||||
      feed_command('earlier 1f')
 | 
			
		||||
      expect([[
 | 
			
		||||
        one one one
 | 
			
		||||
        two
 | 
			
		||||
        two]])
 | 
			
		||||
      execute('earlier 1f')
 | 
			
		||||
      feed_command('earlier 1f')
 | 
			
		||||
      expect('one one one')
 | 
			
		||||
      execute('earlier 1f')
 | 
			
		||||
      feed_command('earlier 1f')
 | 
			
		||||
      expect_empty_buffer()
 | 
			
		||||
      execute('later 1f')
 | 
			
		||||
      feed_command('later 1f')
 | 
			
		||||
      expect('one one one')
 | 
			
		||||
      execute('later 1f')
 | 
			
		||||
      feed_command('later 1f')
 | 
			
		||||
      expect([[
 | 
			
		||||
        one one one
 | 
			
		||||
        two
 | 
			
		||||
        two]])
 | 
			
		||||
      execute('later 1f')
 | 
			
		||||
      feed_command('later 1f')
 | 
			
		||||
      expect([[
 | 
			
		||||
        one one one
 | 
			
		||||
        two
 | 
			
		||||
@@ -221,7 +221,7 @@ describe('undo tree:', function()
 | 
			
		||||
      c
 | 
			
		||||
      12]])
 | 
			
		||||
    feed('od<esc>')
 | 
			
		||||
    execute('so! Xtest.source')
 | 
			
		||||
    feed_command('so! Xtest.source')
 | 
			
		||||
    expect([[
 | 
			
		||||
 | 
			
		||||
      a
 | 
			
		||||
 
 | 
			
		||||
@@ -1,17 +1,17 @@
 | 
			
		||||
-- Tests for tab pages
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local feed, insert, source, clear, execute, expect, eval, eq =
 | 
			
		||||
local feed, insert, source, clear, command, expect, eval, eq =
 | 
			
		||||
  helpers.feed, helpers.insert, helpers.source, helpers.clear,
 | 
			
		||||
  helpers.execute, helpers.expect, helpers.eval, helpers.eq
 | 
			
		||||
  helpers.command, helpers.expect, helpers.eval, helpers.eq
 | 
			
		||||
 | 
			
		||||
describe('tab pages', function()
 | 
			
		||||
  before_each(clear)
 | 
			
		||||
 | 
			
		||||
  it('can be opened and closed', function()
 | 
			
		||||
    execute('tabnew')
 | 
			
		||||
    command('tabnew')
 | 
			
		||||
    eq(2, eval('tabpagenr()'))
 | 
			
		||||
    execute('quit')
 | 
			
		||||
    command('quit')
 | 
			
		||||
    eq(1, eval('tabpagenr()'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
@@ -25,7 +25,7 @@ describe('tab pages', function()
 | 
			
		||||
      tabrewind
 | 
			
		||||
    ]])
 | 
			
		||||
    eq('this is tab page 1', eval("getline('$')"))
 | 
			
		||||
    execute('tablast')
 | 
			
		||||
    command('tablast')
 | 
			
		||||
    eq('this is tab page 4', eval("getline('$')"))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
@@ -44,7 +44,7 @@ describe('tab pages', function()
 | 
			
		||||
    eq(100, eval('gettabvar(2, "val_num")'))
 | 
			
		||||
    eq('SetTabVar test', eval('gettabvar(2, "val_str")'))
 | 
			
		||||
    eq({'red', 'blue', 'green'}, eval('gettabvar(2, "val_list")'))
 | 
			
		||||
    execute('tabnext 2')
 | 
			
		||||
    command('tabnext 2')
 | 
			
		||||
    eq(100, eval('t:val_num'))
 | 
			
		||||
    eq('SetTabVar test', eval('t:val_str'))
 | 
			
		||||
    eq({'red', 'blue', 'green'}, eval('t:val_list'))
 | 
			
		||||
@@ -52,8 +52,8 @@ describe('tab pages', function()
 | 
			
		||||
 | 
			
		||||
  it('work together with the drop feature and loaded buffers', function()
 | 
			
		||||
    -- Test for ":tab drop exist-file" to keep current window.
 | 
			
		||||
    execute('sp test1')
 | 
			
		||||
    execute('tab drop test1')
 | 
			
		||||
    command('sp test1')
 | 
			
		||||
    command('tab drop test1')
 | 
			
		||||
    eq(1, eval('tabpagenr("$")'))
 | 
			
		||||
    eq(2, eval('winnr("$")'))
 | 
			
		||||
    eq(1, eval('winnr()'))
 | 
			
		||||
@@ -61,8 +61,8 @@ describe('tab pages', function()
 | 
			
		||||
 | 
			
		||||
  it('work together with the drop feature and new files', function()
 | 
			
		||||
    -- Test for ":tab drop new-file" to keep current window of tabpage 1.
 | 
			
		||||
    execute('split')
 | 
			
		||||
    execute('tab drop newfile')
 | 
			
		||||
    command('split')
 | 
			
		||||
    command('tab drop newfile')
 | 
			
		||||
    eq(2, eval('tabpagenr("$")'))
 | 
			
		||||
    eq(2, eval('tabpagewinnr(1, "$")'))
 | 
			
		||||
    eq(1, eval('tabpagewinnr(1)'))
 | 
			
		||||
@@ -71,52 +71,52 @@ describe('tab pages', function()
 | 
			
		||||
  it('work together with the drop feature and multi loaded buffers', function()
 | 
			
		||||
    -- Test for ":tab drop multi-opend-file" to keep current tabpage and
 | 
			
		||||
    -- window.
 | 
			
		||||
    execute('new test1')
 | 
			
		||||
    execute('tabnew')
 | 
			
		||||
    execute('new test1')
 | 
			
		||||
    execute('tab drop test1')
 | 
			
		||||
    command('new test1')
 | 
			
		||||
    command('tabnew')
 | 
			
		||||
    command('new test1')
 | 
			
		||||
    command('tab drop test1')
 | 
			
		||||
    eq(2, eval('tabpagenr()'))
 | 
			
		||||
    eq(2, eval('tabpagewinnr(2, "$")'))
 | 
			
		||||
    eq(1, eval('tabpagewinnr(2)'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('can be navigated with :tabmove', function()
 | 
			
		||||
    execute('lang C')
 | 
			
		||||
    execute('for i in range(9) | tabnew | endfor')
 | 
			
		||||
    command('lang C')
 | 
			
		||||
    command('for i in range(9) | tabnew | endfor')
 | 
			
		||||
    feed('1gt')
 | 
			
		||||
    eq(1, eval('tabpagenr()'))
 | 
			
		||||
    execute('tabmove 5')
 | 
			
		||||
    command('tabmove 5')
 | 
			
		||||
    eq(5, eval('tabpagenr()'))
 | 
			
		||||
    execute('.tabmove')
 | 
			
		||||
    command('.tabmove')
 | 
			
		||||
    eq(5, eval('tabpagenr()'))
 | 
			
		||||
    execute('tabmove -')
 | 
			
		||||
    command('tabmove -')
 | 
			
		||||
    eq(4, eval('tabpagenr()'))
 | 
			
		||||
    execute('tabmove +')
 | 
			
		||||
    command('tabmove +')
 | 
			
		||||
    eq(5, eval('tabpagenr()'))
 | 
			
		||||
    execute('tabmove -2')
 | 
			
		||||
    command('tabmove -2')
 | 
			
		||||
    eq(3, eval('tabpagenr()'))
 | 
			
		||||
    execute('tabmove +4')
 | 
			
		||||
    command('tabmove +4')
 | 
			
		||||
    eq(7, eval('tabpagenr()'))
 | 
			
		||||
    execute('tabmove')
 | 
			
		||||
    command('tabmove')
 | 
			
		||||
    eq(10, eval('tabpagenr()'))
 | 
			
		||||
    execute('0tabmove')
 | 
			
		||||
    command('0tabmove')
 | 
			
		||||
    eq(1, eval('tabpagenr()'))
 | 
			
		||||
    execute('$tabmove')
 | 
			
		||||
    command('$tabmove')
 | 
			
		||||
    eq(10, eval('tabpagenr()'))
 | 
			
		||||
    execute('tabmove 0')
 | 
			
		||||
    command('tabmove 0')
 | 
			
		||||
    eq(1, eval('tabpagenr()'))
 | 
			
		||||
    execute('tabmove $')
 | 
			
		||||
    command('tabmove $')
 | 
			
		||||
    eq(10, eval('tabpagenr()'))
 | 
			
		||||
    execute('3tabmove')
 | 
			
		||||
    command('3tabmove')
 | 
			
		||||
    eq(4, eval('tabpagenr()'))
 | 
			
		||||
    execute('7tabmove 5')
 | 
			
		||||
    command('7tabmove 5')
 | 
			
		||||
    eq(5, eval('tabpagenr()'))
 | 
			
		||||
    execute('let a="No error caught."')
 | 
			
		||||
    execute('try')
 | 
			
		||||
    execute('tabmove foo')
 | 
			
		||||
    execute('catch E474')
 | 
			
		||||
    execute('let a="E474 caught."')
 | 
			
		||||
    execute('endtry')
 | 
			
		||||
    command('let a="No error caught."')
 | 
			
		||||
    command('try')
 | 
			
		||||
    command('tabmove foo')
 | 
			
		||||
    command('catch E474')
 | 
			
		||||
    command('let a="E474 caught."')
 | 
			
		||||
    command('endtry')
 | 
			
		||||
    eq('E474 caught.', eval('a'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
@@ -3,7 +3,7 @@
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local Screen = require('test.functional.ui.screen')
 | 
			
		||||
local feed, insert = helpers.feed, helpers.insert
 | 
			
		||||
local eval, clear, execute = helpers.eval, helpers.clear, helpers.execute
 | 
			
		||||
local eval, clear, command = helpers.eval, helpers.clear, helpers.command
 | 
			
		||||
local eq, neq = helpers.eq, helpers.neq
 | 
			
		||||
 | 
			
		||||
describe('063: Test for ":match", "matchadd()" and related functions', function()
 | 
			
		||||
@@ -15,12 +15,12 @@ describe('063: Test for ":match", "matchadd()" and related functions', function(
 | 
			
		||||
 | 
			
		||||
    -- Check that "matcharg()" returns the correct group and pattern if a match
 | 
			
		||||
    -- is defined.
 | 
			
		||||
    execute("highlight MyGroup1 term=bold ctermbg=red guibg=red")
 | 
			
		||||
    execute("highlight MyGroup2 term=italic ctermbg=green guibg=green")
 | 
			
		||||
    execute("highlight MyGroup3 term=underline ctermbg=blue guibg=blue")
 | 
			
		||||
    execute("match MyGroup1 /TODO/")
 | 
			
		||||
    execute("2match MyGroup2 /FIXME/")
 | 
			
		||||
    execute("3match MyGroup3 /XXX/")
 | 
			
		||||
    command("highlight MyGroup1 term=bold ctermbg=red guibg=red")
 | 
			
		||||
    command("highlight MyGroup2 term=italic ctermbg=green guibg=green")
 | 
			
		||||
    command("highlight MyGroup3 term=underline ctermbg=blue guibg=blue")
 | 
			
		||||
    command("match MyGroup1 /TODO/")
 | 
			
		||||
    command("2match MyGroup2 /FIXME/")
 | 
			
		||||
    command("3match MyGroup3 /XXX/")
 | 
			
		||||
    eq({'MyGroup1', 'TODO'}, eval('matcharg(1)'))
 | 
			
		||||
    eq({'MyGroup2', 'FIXME'}, eval('matcharg(2)'))
 | 
			
		||||
    eq({'MyGroup3', 'XXX'}, eval('matcharg(3)'))
 | 
			
		||||
@@ -31,18 +31,18 @@ describe('063: Test for ":match", "matchadd()" and related functions', function(
 | 
			
		||||
    eq({}, eval('matcharg(4)'))
 | 
			
		||||
 | 
			
		||||
    -- Check that "matcharg()" returns ['', ''] if a match is not defined.
 | 
			
		||||
    execute("match")
 | 
			
		||||
    execute("2match")
 | 
			
		||||
    execute("3match")
 | 
			
		||||
    command("match")
 | 
			
		||||
    command("2match")
 | 
			
		||||
    command("3match")
 | 
			
		||||
    eq({'', ''}, eval('matcharg(1)'))
 | 
			
		||||
    eq({'', ''}, eval('matcharg(2)'))
 | 
			
		||||
    eq({'', ''}, eval('matcharg(3)'))
 | 
			
		||||
 | 
			
		||||
    -- Check that "matchadd()" and "getmatches()" agree on added matches and
 | 
			
		||||
    -- that default values apply.
 | 
			
		||||
    execute("let m1 = matchadd('MyGroup1', 'TODO')")
 | 
			
		||||
    execute("let m2 = matchadd('MyGroup2', 'FIXME', 42)")
 | 
			
		||||
    execute("let m3 = matchadd('MyGroup3', 'XXX', 60, 17)")
 | 
			
		||||
    command("let m1 = matchadd('MyGroup1', 'TODO')")
 | 
			
		||||
    command("let m2 = matchadd('MyGroup2', 'FIXME', 42)")
 | 
			
		||||
    command("let m3 = matchadd('MyGroup3', 'XXX', 60, 17)")
 | 
			
		||||
    eq({{group = 'MyGroup1', pattern = 'TODO', priority = 10, id = 4},
 | 
			
		||||
        {group = 'MyGroup2', pattern = 'FIXME', priority = 42, id = 5},
 | 
			
		||||
        {group = 'MyGroup3', pattern = 'XXX', priority = 60, id = 17}},
 | 
			
		||||
@@ -50,55 +50,55 @@ describe('063: Test for ":match", "matchadd()" and related functions', function(
 | 
			
		||||
 | 
			
		||||
    -- Check that "matchdelete()" deletes the matches defined in the previous
 | 
			
		||||
    -- test correctly.
 | 
			
		||||
    execute("call matchdelete(m1)")
 | 
			
		||||
    execute("call matchdelete(m2)")
 | 
			
		||||
    execute("call matchdelete(m3)")
 | 
			
		||||
    command("call matchdelete(m1)")
 | 
			
		||||
    command("call matchdelete(m2)")
 | 
			
		||||
    command("call matchdelete(m3)")
 | 
			
		||||
    eq({}, eval('getmatches()'))
 | 
			
		||||
 | 
			
		||||
    --- Check that "matchdelete()" returns 0 if successful and otherwise -1.
 | 
			
		||||
    execute("let m = matchadd('MyGroup1', 'TODO')")
 | 
			
		||||
    command("let m = matchadd('MyGroup1', 'TODO')")
 | 
			
		||||
    eq(0, eval('matchdelete(m)'))
 | 
			
		||||
 | 
			
		||||
    -- matchdelete throws error and returns -1 on failure
 | 
			
		||||
    neq(true, pcall(function() eval('matchdelete(42)') end))
 | 
			
		||||
    execute("let r2 = matchdelete(42)")
 | 
			
		||||
    command("let r2 = matchdelete(42)")
 | 
			
		||||
    eq(-1, eval('r2'))
 | 
			
		||||
 | 
			
		||||
    -- Check that "clearmatches()" clears all matches defined by ":match" and
 | 
			
		||||
    -- "matchadd()".
 | 
			
		||||
    execute("let m1 = matchadd('MyGroup1', 'TODO')")
 | 
			
		||||
    execute("let m2 = matchadd('MyGroup2', 'FIXME', 42)")
 | 
			
		||||
    execute("let m3 = matchadd('MyGroup3', 'XXX', 60, 17)")
 | 
			
		||||
    execute("match MyGroup1 /COFFEE/")
 | 
			
		||||
    execute("2match MyGroup2 /HUMPPA/")
 | 
			
		||||
    execute("3match MyGroup3 /VIM/")
 | 
			
		||||
    execute("call clearmatches()")
 | 
			
		||||
    command("let m1 = matchadd('MyGroup1', 'TODO')")
 | 
			
		||||
    command("let m2 = matchadd('MyGroup2', 'FIXME', 42)")
 | 
			
		||||
    command("let m3 = matchadd('MyGroup3', 'XXX', 60, 17)")
 | 
			
		||||
    command("match MyGroup1 /COFFEE/")
 | 
			
		||||
    command("2match MyGroup2 /HUMPPA/")
 | 
			
		||||
    command("3match MyGroup3 /VIM/")
 | 
			
		||||
    command("call clearmatches()")
 | 
			
		||||
    eq({}, eval('getmatches()'))
 | 
			
		||||
 | 
			
		||||
    -- Check that "setmatches()" restores a list of matches saved by
 | 
			
		||||
    -- "getmatches()" without changes. (Matches with equal priority must also
 | 
			
		||||
    -- remain in the same order.)
 | 
			
		||||
    execute("let m1 = matchadd('MyGroup1', 'TODO')")
 | 
			
		||||
    execute("let m2 = matchadd('MyGroup2', 'FIXME', 42)")
 | 
			
		||||
    execute("let m3 = matchadd('MyGroup3', 'XXX', 60, 17)")
 | 
			
		||||
    execute("match MyGroup1 /COFFEE/")
 | 
			
		||||
    execute("2match MyGroup2 /HUMPPA/")
 | 
			
		||||
    execute("3match MyGroup3 /VIM/")
 | 
			
		||||
    execute("let ml = getmatches()")
 | 
			
		||||
    command("let m1 = matchadd('MyGroup1', 'TODO')")
 | 
			
		||||
    command("let m2 = matchadd('MyGroup2', 'FIXME', 42)")
 | 
			
		||||
    command("let m3 = matchadd('MyGroup3', 'XXX', 60, 17)")
 | 
			
		||||
    command("match MyGroup1 /COFFEE/")
 | 
			
		||||
    command("2match MyGroup2 /HUMPPA/")
 | 
			
		||||
    command("3match MyGroup3 /VIM/")
 | 
			
		||||
    command("let ml = getmatches()")
 | 
			
		||||
    local ml = eval("ml")
 | 
			
		||||
    execute("call clearmatches()")
 | 
			
		||||
    execute("call setmatches(ml)")
 | 
			
		||||
    command("call clearmatches()")
 | 
			
		||||
    command("call setmatches(ml)")
 | 
			
		||||
    eq(ml, eval('getmatches()'))
 | 
			
		||||
 | 
			
		||||
    -- Check that "setmatches()" can correctly restore the matches from matchaddpos()
 | 
			
		||||
    execute("call clearmatches()")
 | 
			
		||||
    execute("call setmatches(ml)")
 | 
			
		||||
    command("call clearmatches()")
 | 
			
		||||
    command("call setmatches(ml)")
 | 
			
		||||
    eq(ml, eval('getmatches()'))
 | 
			
		||||
 | 
			
		||||
    -- Check that "setmatches()" will not add two matches with the same ID. The
 | 
			
		||||
    -- expected behaviour (for now) is to add the first match but not the
 | 
			
		||||
    -- second and to return -1.
 | 
			
		||||
    execute("let r1 = setmatches([{'group': 'MyGroup1', 'pattern': 'TODO', 'priority': 10, 'id': 1}, {'group': 'MyGroup2', 'pattern': 'FIXME', 'priority': 10, 'id': 1}])")
 | 
			
		||||
    command("let r1 = setmatches([{'group': 'MyGroup1', 'pattern': 'TODO', 'priority': 10, 'id': 1}, {'group': 'MyGroup2', 'pattern': 'FIXME', 'priority': 10, 'id': 1}])")
 | 
			
		||||
    feed("<cr>")
 | 
			
		||||
    eq(-1, eval("r1"))
 | 
			
		||||
    eq({{group = 'MyGroup1', pattern = 'TODO', priority = 10, id = 1}}, eval('getmatches()'))
 | 
			
		||||
@@ -108,18 +108,18 @@ describe('063: Test for ":match", "matchadd()" and related functions', function(
 | 
			
		||||
    -- return values.)
 | 
			
		||||
    eq(0,eval("setmatches([])"))
 | 
			
		||||
    eq(0,eval("setmatches([{'group': 'MyGroup1', 'pattern': 'TODO', 'priority': 10, 'id': 1}])"))
 | 
			
		||||
    execute("call clearmatches()")
 | 
			
		||||
    execute("let rf1 = setmatches(0)")
 | 
			
		||||
    command("call clearmatches()")
 | 
			
		||||
    command("let rf1 = setmatches(0)")
 | 
			
		||||
    eq(-1, eval('rf1'))
 | 
			
		||||
    execute("let rf2 = setmatches([0])")
 | 
			
		||||
    command("let rf2 = setmatches([0])")
 | 
			
		||||
    eq(-1, eval('rf2'))
 | 
			
		||||
    execute("let rf3 = setmatches([{'wrong key': 'wrong value'}])")
 | 
			
		||||
    command("let rf3 = setmatches([{'wrong key': 'wrong value'}])")
 | 
			
		||||
    feed("<cr>")
 | 
			
		||||
    eq(-1, eval('rf3'))
 | 
			
		||||
 | 
			
		||||
    -- Check that "matchaddpos()" positions matches correctly
 | 
			
		||||
    insert('abcdefghijklmnopq')
 | 
			
		||||
    execute("call matchaddpos('MyGroup1', [[1, 5], [1, 8, 3]], 10, 3)")
 | 
			
		||||
    command("call matchaddpos('MyGroup1', [[1, 5], [1, 8, 3]], 10, 3)")
 | 
			
		||||
    screen:expect([[
 | 
			
		||||
      abcd{1:e}fg{1:hij}klmnop^q                       |
 | 
			
		||||
      ~                                       |
 | 
			
		||||
@@ -128,9 +128,9 @@ describe('063: Test for ":match", "matchadd()" and related functions', function(
 | 
			
		||||
                                              |
 | 
			
		||||
    ]], {[1] = {background = Screen.colors.Red}}, {{bold = true, foreground = Screen.colors.Blue}})
 | 
			
		||||
 | 
			
		||||
    execute("call clearmatches()")
 | 
			
		||||
    execute("call setline(1, 'abcdΣabcdef')")
 | 
			
		||||
    execute("call matchaddpos('MyGroup1', [[1, 4, 2], [1, 9, 2]])")
 | 
			
		||||
    command("call clearmatches()")
 | 
			
		||||
    command("call setline(1, 'abcdΣabcdef')")
 | 
			
		||||
    command("call matchaddpos('MyGroup1', [[1, 4, 2], [1, 9, 2]])")
 | 
			
		||||
    screen:expect([[
 | 
			
		||||
      abc{1:dΣ}ab{1:cd}e^f                             |
 | 
			
		||||
      ~                                       |
 | 
			
		||||
 
 | 
			
		||||
@@ -2,7 +2,7 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local insert, source = helpers.insert, helpers.source
 | 
			
		||||
local clear, execute, expect = helpers.clear, helpers.execute, helpers.expect
 | 
			
		||||
local clear, command, expect = helpers.clear, helpers.command, helpers.expect
 | 
			
		||||
 | 
			
		||||
describe('floating point and logical operators', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
@@ -49,7 +49,7 @@ describe('floating point and logical operators', function()
 | 
			
		||||
    -- The test will throw an error if this line is included in a source()
 | 
			
		||||
    -- call.  The vim expression throws a exception "E745: Using a List as a
 | 
			
		||||
    -- Number" which is fatal in a source() call but not in a execute() call.
 | 
			
		||||
    execute([[$put =printf('%d', abs([1, 2, 3]))]])
 | 
			
		||||
    command([[$put =printf('%d', abs([1, 2, 3]))]])
 | 
			
		||||
 | 
			
		||||
    source([[
 | 
			
		||||
      $put =printf('%g', abs(14.56))
 | 
			
		||||
@@ -104,7 +104,7 @@ describe('floating point and logical operators', function()
 | 
			
		||||
 | 
			
		||||
    -- This line can not be included in a source() call.  It throws a "E805:
 | 
			
		||||
    -- Using a Float as a Number".  Also compare comment above.
 | 
			
		||||
    execute('$put =invert(1.0)')
 | 
			
		||||
    command('$put =invert(1.0)')
 | 
			
		||||
 | 
			
		||||
    -- Assert buffer contents.
 | 
			
		||||
    expect([=[
 | 
			
		||||
 
 | 
			
		||||
@@ -3,7 +3,7 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear, feed, insert = helpers.clear, helpers.feed, helpers.insert
 | 
			
		||||
local execute, expect = helpers.execute, helpers.expect
 | 
			
		||||
local feed_command, expect = helpers.feed_command, helpers.expect
 | 
			
		||||
 | 
			
		||||
describe('visual block shift and tab characters', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
@@ -24,23 +24,23 @@ describe('visual block shift and tab characters', function()
 | 
			
		||||
 | 
			
		||||
    feed('gg')
 | 
			
		||||
    feed([[fe<C-v>4jR<esc>ugvr1:'<lt>,'>yank A<cr>]])
 | 
			
		||||
    execute('/^abcdefgh')
 | 
			
		||||
    feed_command('/^abcdefgh')
 | 
			
		||||
    feed('<C-v>4jI    <esc>j<lt><lt>11|D')
 | 
			
		||||
    feed('j7|a		<esc>')
 | 
			
		||||
    feed('j7|a		   <esc>')
 | 
			
		||||
    feed('j7|a	       	<esc>4k13|<C-v>4j<lt>')
 | 
			
		||||
    execute('$-5,$yank A')
 | 
			
		||||
    execute([[$-4,$s/\s\+//g]])
 | 
			
		||||
    feed_command('$-5,$yank A')
 | 
			
		||||
    feed_command([[$-4,$s/\s\+//g]])
 | 
			
		||||
    feed('<C-v>4kI    <esc>j<lt><lt>')
 | 
			
		||||
    feed('j7|a		<esc>')
 | 
			
		||||
    feed('j7|a					<esc>')
 | 
			
		||||
    feed('j7|a	       		<esc>4k13|<C-v>4j3<lt>')
 | 
			
		||||
    execute('$-4,$yank A')
 | 
			
		||||
    feed_command('$-4,$yank A')
 | 
			
		||||
 | 
			
		||||
    -- Put @a and clean empty lines
 | 
			
		||||
    execute('%d')
 | 
			
		||||
    execute('0put a')
 | 
			
		||||
    execute('$d')
 | 
			
		||||
    feed_command('%d')
 | 
			
		||||
    feed_command('0put a')
 | 
			
		||||
    feed_command('$d')
 | 
			
		||||
 | 
			
		||||
    -- Assert buffer contents.
 | 
			
		||||
    expect([[
 | 
			
		||||
 
 | 
			
		||||
@@ -3,32 +3,32 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear = helpers.clear
 | 
			
		||||
local execute, expect = helpers.execute, helpers.expect
 | 
			
		||||
local command, expect = helpers.command, helpers.expect
 | 
			
		||||
 | 
			
		||||
describe('augroup when calling exists()', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
 | 
			
		||||
  it('is working', function()
 | 
			
		||||
    execute('let results=[]')
 | 
			
		||||
    execute('call add(results, "##BufEnter: " . exists("##BufEnter"))')
 | 
			
		||||
    execute('call add(results, "#BufEnter: " . exists("#BufEnter"))')
 | 
			
		||||
    execute('au BufEnter * let g:entered=1')
 | 
			
		||||
    execute('call add(results, "#BufEnter: " . exists("#BufEnter"))')
 | 
			
		||||
    execute('call add(results, "#auexists#BufEnter: " . exists("#auexists#BufEnter"))')
 | 
			
		||||
    execute('augroup auexists', 'au BufEnter * let g:entered=1', 'augroup END')
 | 
			
		||||
    execute('call add(results, "#auexists#BufEnter: " . exists("#auexists#BufEnter"))')
 | 
			
		||||
    execute('call add(results, "#BufEnter#*.test: " . exists("#BufEnter#*.test"))')
 | 
			
		||||
    execute('au BufEnter *.test let g:entered=1')
 | 
			
		||||
    execute('call add(results, "#BufEnter#*.test: " . exists("#BufEnter#*.test"))')
 | 
			
		||||
    execute('edit testfile.test')
 | 
			
		||||
    execute('call add(results, "#BufEnter#<buffer>: " . exists("#BufEnter#<buffer>"))')
 | 
			
		||||
    execute('au BufEnter <buffer> let g:entered=1')
 | 
			
		||||
    execute('call add(results, "#BufEnter#<buffer>: " . exists("#BufEnter#<buffer>"))')
 | 
			
		||||
    execute('edit testfile2.test')
 | 
			
		||||
    execute('call add(results, "#BufEnter#<buffer>: " . exists("#BufEnter#<buffer>"))')
 | 
			
		||||
    execute('bf')
 | 
			
		||||
    execute('call append(0, results)')
 | 
			
		||||
    execute('$d')
 | 
			
		||||
    command('let results=[]')
 | 
			
		||||
    command('call add(results, "##BufEnter: " . exists("##BufEnter"))')
 | 
			
		||||
    command('call add(results, "#BufEnter: " . exists("#BufEnter"))')
 | 
			
		||||
    command('au BufEnter * let g:entered=1')
 | 
			
		||||
    command('call add(results, "#BufEnter: " . exists("#BufEnter"))')
 | 
			
		||||
    command('call add(results, "#auexists#BufEnter: " . exists("#auexists#BufEnter"))')
 | 
			
		||||
    command('augroup auexists', 'au BufEnter * let g:entered=1', 'augroup END')
 | 
			
		||||
    command('call add(results, "#auexists#BufEnter: " . exists("#auexists#BufEnter"))')
 | 
			
		||||
    command('call add(results, "#BufEnter#*.test: " . exists("#BufEnter#*.test"))')
 | 
			
		||||
    command('au BufEnter *.test let g:entered=1')
 | 
			
		||||
    command('call add(results, "#BufEnter#*.test: " . exists("#BufEnter#*.test"))')
 | 
			
		||||
    command('edit testfile.test')
 | 
			
		||||
    command('call add(results, "#BufEnter#<buffer>: " . exists("#BufEnter#<buffer>"))')
 | 
			
		||||
    command('au BufEnter <buffer> let g:entered=1')
 | 
			
		||||
    command('call add(results, "#BufEnter#<buffer>: " . exists("#BufEnter#<buffer>"))')
 | 
			
		||||
    command('edit testfile2.test')
 | 
			
		||||
    command('call add(results, "#BufEnter#<buffer>: " . exists("#BufEnter#<buffer>"))')
 | 
			
		||||
    command('bf')
 | 
			
		||||
    command('call append(0, results)')
 | 
			
		||||
    command('$d')
 | 
			
		||||
 | 
			
		||||
    -- Assert buffer contents.
 | 
			
		||||
    expect([[
 | 
			
		||||
 
 | 
			
		||||
@@ -3,7 +3,7 @@ local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local feed = helpers.feed
 | 
			
		||||
local clear = helpers.clear
 | 
			
		||||
local insert = helpers.insert
 | 
			
		||||
local execute = helpers.execute
 | 
			
		||||
local feed_command = helpers.feed_command
 | 
			
		||||
local expect = helpers.expect
 | 
			
		||||
 | 
			
		||||
describe('text formatting', function()
 | 
			
		||||
@@ -81,51 +81,51 @@ describe('text formatting', function()
 | 
			
		||||
      # 1 xxxxx
 | 
			
		||||
      ]])
 | 
			
		||||
 | 
			
		||||
    execute('/^{/+1')
 | 
			
		||||
    execute('set noai tw=2 fo=t')
 | 
			
		||||
    feed_command('/^{/+1')
 | 
			
		||||
    feed_command('set noai tw=2 fo=t')
 | 
			
		||||
    feed('gRa b<esc>')
 | 
			
		||||
 | 
			
		||||
    execute('/^{/+1')
 | 
			
		||||
    execute('set ai tw=2 fo=tw')
 | 
			
		||||
    feed_command('/^{/+1')
 | 
			
		||||
    feed_command('set ai tw=2 fo=tw')
 | 
			
		||||
    feed('gqgqjjllab<esc>')
 | 
			
		||||
 | 
			
		||||
    execute('/^{/+1')
 | 
			
		||||
    execute('set tw=3 fo=t')
 | 
			
		||||
    feed_command('/^{/+1')
 | 
			
		||||
    feed_command('set tw=3 fo=t')
 | 
			
		||||
    feed('gqgqo<cr>')
 | 
			
		||||
    feed('a <C-V><C-A><esc><esc>')
 | 
			
		||||
 | 
			
		||||
    execute('/^{/+1')
 | 
			
		||||
    execute('set tw=2 fo=tcq1 comments=:#')
 | 
			
		||||
    feed_command('/^{/+1')
 | 
			
		||||
    feed_command('set tw=2 fo=tcq1 comments=:#')
 | 
			
		||||
    feed('gqgqjgqgqo<cr>')
 | 
			
		||||
    feed('a b<cr>')
 | 
			
		||||
    feed('#a b<esc>')
 | 
			
		||||
 | 
			
		||||
    execute('/^{/+1')
 | 
			
		||||
    execute('set tw=5 fo=tcn comments=:#')
 | 
			
		||||
    feed_command('/^{/+1')
 | 
			
		||||
    feed_command('set tw=5 fo=tcn comments=:#')
 | 
			
		||||
    feed('A b<esc>jA b<esc>')
 | 
			
		||||
 | 
			
		||||
    execute('/^{/+3')
 | 
			
		||||
    execute('set tw=5 fo=t2a si')
 | 
			
		||||
    feed_command('/^{/+3')
 | 
			
		||||
    feed_command('set tw=5 fo=t2a si')
 | 
			
		||||
    feed('i  <esc>A_<esc>')
 | 
			
		||||
 | 
			
		||||
    execute('/^{/+1')
 | 
			
		||||
    execute('set tw=5 fo=qn comments=:#')
 | 
			
		||||
    feed_command('/^{/+1')
 | 
			
		||||
    feed_command('set tw=5 fo=qn comments=:#')
 | 
			
		||||
    feed('gwap<cr>')
 | 
			
		||||
 | 
			
		||||
    execute('/^{/+1')
 | 
			
		||||
    execute('set tw=5 fo=q2 comments=:#')
 | 
			
		||||
    feed_command('/^{/+1')
 | 
			
		||||
    feed_command('set tw=5 fo=q2 comments=:#')
 | 
			
		||||
    feed('gwap<cr>')
 | 
			
		||||
 | 
			
		||||
    execute('/^{/+2')
 | 
			
		||||
    execute('set tw& fo=a')
 | 
			
		||||
    feed_command('/^{/+2')
 | 
			
		||||
    feed_command('set tw& fo=a')
 | 
			
		||||
    feed('I^^<esc><esc>')
 | 
			
		||||
 | 
			
		||||
    execute('/mno pqr/')
 | 
			
		||||
    execute('setl tw=20 fo=an12wcq comments=s1:/*,mb:*,ex:*/')
 | 
			
		||||
    feed_command('/mno pqr/')
 | 
			
		||||
    feed_command('setl tw=20 fo=an12wcq comments=s1:/*,mb:*,ex:*/')
 | 
			
		||||
    feed('A vwx yz<esc>')
 | 
			
		||||
 | 
			
		||||
    execute('/^#/')
 | 
			
		||||
    execute('setl tw=12 fo=tqnc comments=:#')
 | 
			
		||||
    feed_command('/^#/')
 | 
			
		||||
    feed_command('setl tw=12 fo=tqnc comments=:#')
 | 
			
		||||
    feed('A foobar<esc>')
 | 
			
		||||
 | 
			
		||||
    -- Assert buffer contents.
 | 
			
		||||
 
 | 
			
		||||
@@ -4,8 +4,8 @@
 | 
			
		||||
-- Also test byteidx() and byteidxcomp()
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local feed, insert, eq, eval, clear, execute, expect = helpers.feed,
 | 
			
		||||
  helpers.insert, helpers.eq, helpers.eval, helpers.clear, helpers.execute,
 | 
			
		||||
local feed, insert, eq, eval, clear, feed_command, expect = helpers.feed,
 | 
			
		||||
  helpers.insert, helpers.eq, helpers.eval, helpers.clear, helpers.feed_command,
 | 
			
		||||
  helpers.expect
 | 
			
		||||
 | 
			
		||||
describe('multibyte text', function()
 | 
			
		||||
@@ -17,8 +17,8 @@ describe('multibyte text', function()
 | 
			
		||||
      XYZ
 | 
			
		||||
      abc XYZ
 | 
			
		||||
      }]])
 | 
			
		||||
    execute('/^{/+1')
 | 
			
		||||
    execute('set tw=2 fo=t')
 | 
			
		||||
    feed_command('/^{/+1')
 | 
			
		||||
    feed_command('set tw=2 fo=t')
 | 
			
		||||
    feed('gqgqjgqgqo<cr>')
 | 
			
		||||
    feed('XYZ<cr>')
 | 
			
		||||
    feed('abc XYZ<esc><esc>')
 | 
			
		||||
@@ -43,8 +43,8 @@ describe('multibyte text', function()
 | 
			
		||||
      XY
 | 
			
		||||
      X Y
 | 
			
		||||
      }]])
 | 
			
		||||
    execute('/^{/+1')
 | 
			
		||||
    execute('set tw=1 fo=tm')
 | 
			
		||||
    feed_command('/^{/+1')
 | 
			
		||||
    feed_command('set tw=1 fo=tm')
 | 
			
		||||
    feed('gqgqjgqgqjgqgqjgqgqjgqgqo<cr>')
 | 
			
		||||
    feed('X<cr>')
 | 
			
		||||
    feed('Xa<cr>')
 | 
			
		||||
@@ -89,8 +89,8 @@ describe('multibyte text', function()
 | 
			
		||||
      abX c
 | 
			
		||||
      abXY
 | 
			
		||||
      }]])
 | 
			
		||||
    execute('/^{/+1')
 | 
			
		||||
    execute('set tw=2 fo=tm')
 | 
			
		||||
    feed_command('/^{/+1')
 | 
			
		||||
    feed_command('set tw=2 fo=tm')
 | 
			
		||||
    feed('gqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqo<cr>')
 | 
			
		||||
    feed('X<cr>')
 | 
			
		||||
    feed('Xa<cr>')
 | 
			
		||||
@@ -156,8 +156,8 @@ describe('multibyte text', function()
 | 
			
		||||
        X
 | 
			
		||||
        Xa
 | 
			
		||||
      }]])
 | 
			
		||||
    execute('/^{/+1')
 | 
			
		||||
    execute('set ai tw=2 fo=tm')
 | 
			
		||||
    feed_command('/^{/+1')
 | 
			
		||||
    feed_command('set ai tw=2 fo=tm')
 | 
			
		||||
    feed('gqgqjgqgqo<cr>')
 | 
			
		||||
    feed('X<cr>')
 | 
			
		||||
    feed('Xa<esc>')
 | 
			
		||||
@@ -179,8 +179,8 @@ describe('multibyte text', function()
 | 
			
		||||
        X
 | 
			
		||||
        Xa
 | 
			
		||||
      }]])
 | 
			
		||||
    execute('/^{/+1')
 | 
			
		||||
    execute('set noai tw=2 fo=tm')
 | 
			
		||||
    feed_command('/^{/+1')
 | 
			
		||||
    feed_command('set noai tw=2 fo=tm')
 | 
			
		||||
    feed('gqgqjgqgqo<cr>')
 | 
			
		||||
    -- Literal spaces will be trimmed from the by feed().
 | 
			
		||||
    feed('<space><space>X<cr>')
 | 
			
		||||
@@ -211,8 +211,8 @@ describe('multibyte text', function()
 | 
			
		||||
      XXa
 | 
			
		||||
      XXY
 | 
			
		||||
      }]])
 | 
			
		||||
    execute('/^{/+1')
 | 
			
		||||
    execute('set tw=2 fo=cqm comments=n:X')
 | 
			
		||||
    feed_command('/^{/+1')
 | 
			
		||||
    feed_command('set tw=2 fo=cqm comments=n:X')
 | 
			
		||||
    feed('gqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqo<cr>')
 | 
			
		||||
    feed('X<cr>')
 | 
			
		||||
    feed('Xa<cr>')
 | 
			
		||||
@@ -261,8 +261,8 @@ describe('multibyte text', function()
 | 
			
		||||
      {
 | 
			
		||||
      
 | 
			
		||||
      }]])
 | 
			
		||||
    execute('/^{/+1')
 | 
			
		||||
    execute('set tw=2 fo=tm')
 | 
			
		||||
    feed_command('/^{/+1')
 | 
			
		||||
    feed_command('set tw=2 fo=tm')
 | 
			
		||||
    feed('RXa<esc>')
 | 
			
		||||
    expect([[
 | 
			
		||||
      {
 | 
			
		||||
@@ -276,8 +276,8 @@ describe('multibyte text', function()
 | 
			
		||||
      {
 | 
			
		||||
      ‘ two three ’ four
 | 
			
		||||
      }]])
 | 
			
		||||
    execute('/^{/+1')
 | 
			
		||||
    execute('set mps+=‘:’')
 | 
			
		||||
    feed_command('/^{/+1')
 | 
			
		||||
    feed_command('set mps+=‘:’')
 | 
			
		||||
    feed('d%<cr>')
 | 
			
		||||
    expect([[
 | 
			
		||||
      {
 | 
			
		||||
@@ -299,8 +299,8 @@ describe('multibyte text', function()
 | 
			
		||||
    insert([[
 | 
			
		||||
      á
 | 
			
		||||
      x]])
 | 
			
		||||
    execute('set whichwrap+=h')
 | 
			
		||||
    execute('/^x')
 | 
			
		||||
    feed_command('set whichwrap+=h')
 | 
			
		||||
    feed_command('/^x')
 | 
			
		||||
    feed('dh')
 | 
			
		||||
    expect([[
 | 
			
		||||
      áx]])
 | 
			
		||||
@@ -308,9 +308,9 @@ describe('multibyte text', function()
 | 
			
		||||
 | 
			
		||||
  it('can be queried with byteidx() and byteidxcomp()', function()
 | 
			
		||||
    -- One char of two bytes.
 | 
			
		||||
    execute("let a = '.é.'")
 | 
			
		||||
    feed_command("let a = '.é.'")
 | 
			
		||||
    -- Normal e with composing char.
 | 
			
		||||
    execute("let b = '.é.'")
 | 
			
		||||
    feed_command("let b = '.é.'")
 | 
			
		||||
    eq(0, eval('byteidx(a, 0)'))
 | 
			
		||||
    eq(1, eval('byteidx(a, 1)'))
 | 
			
		||||
    eq(3, eval('byteidx(a, 2)'))
 | 
			
		||||
 
 | 
			
		||||
@@ -4,7 +4,7 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local feed, insert = helpers.feed, helpers.insert
 | 
			
		||||
local clear, execute, expect = helpers.clear, helpers.execute, helpers.expect
 | 
			
		||||
local clear, feed_command, expect = helpers.clear, helpers.feed_command, helpers.expect
 | 
			
		||||
 | 
			
		||||
describe('72', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
@@ -17,30 +17,30 @@ describe('72', function()
 | 
			
		||||
      123456789]])
 | 
			
		||||
 | 
			
		||||
    -- Test 'undofile': first a simple one-line change.
 | 
			
		||||
    execute('set visualbell')
 | 
			
		||||
    execute('set ul=100 undofile undodir=. nomore')
 | 
			
		||||
    execute('e! Xtestfile')
 | 
			
		||||
    feed_command('set visualbell')
 | 
			
		||||
    feed_command('set ul=100 undofile undodir=. nomore')
 | 
			
		||||
    feed_command('e! Xtestfile')
 | 
			
		||||
    feed('ggdGithis is one line<esc>:set ul=100<cr>')
 | 
			
		||||
    execute('s/one/ONE/')
 | 
			
		||||
    execute('set ul=100')
 | 
			
		||||
    execute('w')
 | 
			
		||||
    execute('bwipe!')
 | 
			
		||||
    execute('e Xtestfile')
 | 
			
		||||
    feed_command('s/one/ONE/')
 | 
			
		||||
    feed_command('set ul=100')
 | 
			
		||||
    feed_command('w')
 | 
			
		||||
    feed_command('bwipe!')
 | 
			
		||||
    feed_command('e Xtestfile')
 | 
			
		||||
    feed('u:.w! test.out<cr>')
 | 
			
		||||
 | 
			
		||||
    -- Test 'undofile', change in original file fails check.
 | 
			
		||||
    execute('set noundofile')
 | 
			
		||||
    execute('e! Xtestfile')
 | 
			
		||||
    execute('s/line/Line/')
 | 
			
		||||
    execute('w')
 | 
			
		||||
    execute('set undofile')
 | 
			
		||||
    execute('bwipe!')
 | 
			
		||||
    execute('e Xtestfile')
 | 
			
		||||
    feed_command('set noundofile')
 | 
			
		||||
    feed_command('e! Xtestfile')
 | 
			
		||||
    feed_command('s/line/Line/')
 | 
			
		||||
    feed_command('w')
 | 
			
		||||
    feed_command('set undofile')
 | 
			
		||||
    feed_command('bwipe!')
 | 
			
		||||
    feed_command('e Xtestfile')
 | 
			
		||||
    ---- TODO: this beeps.
 | 
			
		||||
    feed('u:.w >>test.out<cr>')
 | 
			
		||||
 | 
			
		||||
    -- Test 'undofile', add 10 lines, delete 6 lines, undo 3.
 | 
			
		||||
    execute('set undofile')
 | 
			
		||||
    feed_command('set undofile')
 | 
			
		||||
    feed('ggdGione<cr>')
 | 
			
		||||
    feed('two<cr>')
 | 
			
		||||
    feed('three<cr>')
 | 
			
		||||
@@ -57,20 +57,20 @@ describe('72', function()
 | 
			
		||||
    feed('dd:set ul=100<cr>')
 | 
			
		||||
    feed('dd:set ul=100<cr>')
 | 
			
		||||
    feed('dd:set ul=100<cr>')
 | 
			
		||||
    execute('w')
 | 
			
		||||
    execute('bwipe!')
 | 
			
		||||
    execute('e Xtestfile')
 | 
			
		||||
    feed_command('w')
 | 
			
		||||
    feed_command('bwipe!')
 | 
			
		||||
    feed_command('e Xtestfile')
 | 
			
		||||
    feed('uuu:w >>test.out<cr>')
 | 
			
		||||
 | 
			
		||||
    -- Test that reading the undofiles when setting undofile works.
 | 
			
		||||
    execute('set noundofile ul=0')
 | 
			
		||||
    feed_command('set noundofile ul=0')
 | 
			
		||||
    feed('i<cr>')
 | 
			
		||||
    feed('<esc>u:e! Xtestfile<cr>')
 | 
			
		||||
    execute('set undofile ul=100')
 | 
			
		||||
    feed_command('set undofile ul=100')
 | 
			
		||||
    feed('uuuuuu:w >>test.out<cr>')
 | 
			
		||||
 | 
			
		||||
    ---- Open the output to see if it meets the expections
 | 
			
		||||
    execute('e! test.out')
 | 
			
		||||
    feed_command('e! test.out')
 | 
			
		||||
 | 
			
		||||
    -- Assert buffer contents.
 | 
			
		||||
    expect([[
 | 
			
		||||
 
 | 
			
		||||
@@ -2,8 +2,8 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local lfs = require('lfs')
 | 
			
		||||
local clear, execute, eq, neq, eval, wait, spawn =
 | 
			
		||||
  helpers.clear, helpers.execute, helpers.eq, helpers.neq, helpers.eval,
 | 
			
		||||
local clear, command, eq, neq, eval, wait, spawn =
 | 
			
		||||
  helpers.clear, helpers.command, helpers.eq, helpers.neq, helpers.eval,
 | 
			
		||||
  helpers.wait, helpers.spawn
 | 
			
		||||
 | 
			
		||||
describe('storing global variables in ShaDa files', function()
 | 
			
		||||
@@ -26,7 +26,7 @@ describe('storing global variables in ShaDa files', function()
 | 
			
		||||
      71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
 | 
			
		||||
      89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100}
 | 
			
		||||
 | 
			
		||||
    execute(
 | 
			
		||||
    command(
 | 
			
		||||
      -- This will cause a few errors, do it silently.
 | 
			
		||||
      'set visualbell',
 | 
			
		||||
      'set shada+=!',
 | 
			
		||||
@@ -39,18 +39,18 @@ describe('storing global variables in ShaDa files', function()
 | 
			
		||||
    eq(test_dict, eval('MY_GLOBAL_DICT'))
 | 
			
		||||
    eq(test_list, eval('MY_GLOBAL_LIST'))
 | 
			
		||||
 | 
			
		||||
    execute('wsh! ' .. tempname)
 | 
			
		||||
    command('wsh! ' .. tempname)
 | 
			
		||||
    wait()
 | 
			
		||||
 | 
			
		||||
    -- Assert that the shada file exists.
 | 
			
		||||
    neq(nil, lfs.attributes(tempname))
 | 
			
		||||
    execute('unlet MY_GLOBAL_DICT',
 | 
			
		||||
    command('unlet MY_GLOBAL_DICT',
 | 
			
		||||
            'unlet MY_GLOBAL_LIST')
 | 
			
		||||
    -- Assert that the variables where deleted.
 | 
			
		||||
    eq(0, eval('exists("MY_GLOBAL_DICT")'))
 | 
			
		||||
    eq(0, eval('exists("MY_GLOBAL_LIST")'))
 | 
			
		||||
 | 
			
		||||
    execute('rsh! ' .. tempname)
 | 
			
		||||
    command('rsh! ' .. tempname)
 | 
			
		||||
 | 
			
		||||
    eq(test_list, eval('MY_GLOBAL_LIST'))
 | 
			
		||||
    eq(test_dict, eval('MY_GLOBAL_DICT'))
 | 
			
		||||
 
 | 
			
		||||
@@ -3,46 +3,48 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear, feed = helpers.clear, helpers.feed
 | 
			
		||||
local execute, expect = helpers.execute, helpers.expect
 | 
			
		||||
local command, expect = helpers.command, helpers.expect
 | 
			
		||||
local wait = helpers.wait
 | 
			
		||||
 | 
			
		||||
describe('maparg()', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
 | 
			
		||||
  it('is working', function()
 | 
			
		||||
    execute('set cpo-=<')
 | 
			
		||||
    command('set cpo-=<')
 | 
			
		||||
 | 
			
		||||
    -- Test maparg() with a string result
 | 
			
		||||
    execute('map foo<C-V> is<F4>foo')
 | 
			
		||||
    execute('vnoremap <script> <buffer> <expr> <silent> bar isbar')
 | 
			
		||||
    execute([[call append('$', maparg('foo<C-V>'))]])
 | 
			
		||||
    execute([[call append('$', string(maparg('foo<C-V>', '', 0, 1)))]])
 | 
			
		||||
    execute([[call append('$', string(maparg('bar', '', 0, 1)))]])
 | 
			
		||||
    execute('map <buffer> <nowait> foo bar')
 | 
			
		||||
    execute([[call append('$', string(maparg('foo', '', 0, 1)))]])
 | 
			
		||||
    execute('map abc x<char-114>x')
 | 
			
		||||
    execute([[call append('$', maparg('abc'))]])
 | 
			
		||||
    execute('map abc y<S-char-114>y')
 | 
			
		||||
    execute([[call append('$', maparg('abc'))]])
 | 
			
		||||
    command('map foo<C-V> is<F4>foo')
 | 
			
		||||
    command('vnoremap <script> <buffer> <expr> <silent> bar isbar')
 | 
			
		||||
    command([[call append('$', maparg('foo<C-V>'))]])
 | 
			
		||||
    command([[call append('$', string(maparg('foo<C-V>', '', 0, 1)))]])
 | 
			
		||||
    command([[call append('$', string(maparg('bar', '', 0, 1)))]])
 | 
			
		||||
    command('map <buffer> <nowait> foo bar')
 | 
			
		||||
    command([[call append('$', string(maparg('foo', '', 0, 1)))]])
 | 
			
		||||
    command('map abc x<char-114>x')
 | 
			
		||||
    command([[call append('$', maparg('abc'))]])
 | 
			
		||||
    command('map abc y<S-char-114>y')
 | 
			
		||||
    command([[call append('$', maparg('abc'))]])
 | 
			
		||||
    feed('Go<esc>:<cr>')
 | 
			
		||||
    wait()
 | 
			
		||||
 | 
			
		||||
    -- Outside of the range, minimum
 | 
			
		||||
    execute('inoremap <Char-0x1040> a')
 | 
			
		||||
    execute([[execute "normal a\u1040\<Esc>"]])
 | 
			
		||||
    command('inoremap <Char-0x1040> a')
 | 
			
		||||
    command([[execute "normal a\u1040\<Esc>"]])
 | 
			
		||||
 | 
			
		||||
    -- Inside of the range, minimum
 | 
			
		||||
    execute('inoremap <Char-0x103f> b')
 | 
			
		||||
    execute([[execute "normal a\u103f\<Esc>"]])
 | 
			
		||||
    command('inoremap <Char-0x103f> b')
 | 
			
		||||
    command([[execute "normal a\u103f\<Esc>"]])
 | 
			
		||||
 | 
			
		||||
    -- Inside of the range, maximum
 | 
			
		||||
    execute('inoremap <Char-0xf03f> c')
 | 
			
		||||
    execute([[execute "normal a\uf03f\<Esc>"]])
 | 
			
		||||
    command('inoremap <Char-0xf03f> c')
 | 
			
		||||
    command([[execute "normal a\uf03f\<Esc>"]])
 | 
			
		||||
 | 
			
		||||
    -- Outside of the range, maximum
 | 
			
		||||
    execute('inoremap <Char-0xf040> d')
 | 
			
		||||
    execute([[execute "normal a\uf040\<Esc>"]])
 | 
			
		||||
    command('inoremap <Char-0xf040> d')
 | 
			
		||||
    command([[execute "normal a\uf040\<Esc>"]])
 | 
			
		||||
 | 
			
		||||
    -- Remove empty line
 | 
			
		||||
    execute('1d')
 | 
			
		||||
    command('1d')
 | 
			
		||||
 | 
			
		||||
    -- Assert buffer contents.
 | 
			
		||||
    expect([[
 | 
			
		||||
 
 | 
			
		||||
@@ -7,8 +7,12 @@
 | 
			
		||||
-- If it isn't available then the test will be skipped.
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
 | 
			
		||||
local feed = helpers.feed
 | 
			
		||||
local clear, execute, expect = helpers.clear, helpers.execute, helpers.expect
 | 
			
		||||
local wait = helpers.wait
 | 
			
		||||
local clear = helpers.clear
 | 
			
		||||
local expect = helpers.expect
 | 
			
		||||
local command = helpers.command
 | 
			
		||||
 | 
			
		||||
describe('mf_hash_grow()', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
@@ -18,19 +22,21 @@ describe('mf_hash_grow()', function()
 | 
			
		||||
    pending('was not tested because cksum was not found', function() end)
 | 
			
		||||
  else
 | 
			
		||||
    it('is working', function()
 | 
			
		||||
      execute('set fileformat=unix undolevels=-1')
 | 
			
		||||
      command('set fileformat=unix undolevels=-1')
 | 
			
		||||
 | 
			
		||||
      -- Fill the buffer with numbers 1 - 2000000
 | 
			
		||||
      execute('let i = 1')
 | 
			
		||||
      execute('while i <= 2000000 | call append(i, range(i, i + 99)) | let i += 100 | endwhile')
 | 
			
		||||
      command('let i = 1')
 | 
			
		||||
      command('while i <= 2000000 | call append(i, range(i, i + 99)) | let i += 100 | endwhile')
 | 
			
		||||
 | 
			
		||||
      -- Delete empty first line, save to Xtest, and clear buffer
 | 
			
		||||
      feed('ggdd<cr>')
 | 
			
		||||
      execute('w! Xtest')
 | 
			
		||||
      wait()
 | 
			
		||||
      command('w! Xtest')
 | 
			
		||||
      feed('ggdG<cr>')
 | 
			
		||||
      wait()
 | 
			
		||||
 | 
			
		||||
      -- Calculate the cksum of Xtest and delete first line
 | 
			
		||||
      execute('r !cksum Xtest')
 | 
			
		||||
      command('r !cksum Xtest')
 | 
			
		||||
      feed('ggdd<cr>')
 | 
			
		||||
 | 
			
		||||
      -- Assert correct output of cksum.
 | 
			
		||||
 
 | 
			
		||||
@@ -4,7 +4,7 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local feed, insert = helpers.feed, helpers.insert
 | 
			
		||||
local clear, execute, expect = helpers.clear, helpers.execute, helpers.expect
 | 
			
		||||
local clear, feed_command, expect = helpers.clear, helpers.feed_command, helpers.expect
 | 
			
		||||
local eq, eval = helpers.eq, helpers.eval
 | 
			
		||||
 | 
			
		||||
describe('substitue()', function()
 | 
			
		||||
@@ -46,17 +46,17 @@ describe('substitue()', function()
 | 
			
		||||
  end
 | 
			
		||||
 | 
			
		||||
  it('with "set magic" (TEST_1)', function()
 | 
			
		||||
    execute('set magic')
 | 
			
		||||
    feed_command('set magic')
 | 
			
		||||
    test_1_and_2()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('with "set nomagic" (TEST_2)', function()
 | 
			
		||||
    execute('set nomagic')
 | 
			
		||||
    feed_command('set nomagic')
 | 
			
		||||
    test_1_and_2()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('with sub-replace-expression (TEST_3)', function()
 | 
			
		||||
    execute('set magic&')
 | 
			
		||||
    feed_command('set magic&')
 | 
			
		||||
    eq('a\\a', eval([[substitute('aAa', 'A', '\="\\"', '')]]))
 | 
			
		||||
    eq('b\\\\b', eval([[substitute('bBb', 'B', '\="\\\\"', '')]]))
 | 
			
		||||
    eq('c\rc', eval([[substitute('cCc', 'C', '\="]]..'\r'..[["', '')]]))
 | 
			
		||||
@@ -70,7 +70,7 @@ describe('substitue()', function()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('with submatch() (TEST_4)', function()
 | 
			
		||||
    execute('set magic&')
 | 
			
		||||
    feed_command('set magic&')
 | 
			
		||||
    eq('a\\a', eval([[substitute('aAa', 'A', ]] ..
 | 
			
		||||
      [['\=substitute(submatch(0), ".", "\\", "")', '')]]))
 | 
			
		||||
    eq('b\\b', eval([[substitute('bBb', 'B', ]] ..
 | 
			
		||||
@@ -92,7 +92,7 @@ describe('substitue()', function()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('with submatch() (TEST_5)', function()
 | 
			
		||||
    execute('set magic&')
 | 
			
		||||
    feed_command('set magic&')
 | 
			
		||||
    eq('A123456789987654321', eval([[substitute('A123456789', ]] ..
 | 
			
		||||
      [['A\(.\)\(.\)\(.\)\(.\)\(.\)\(.\)\(.\)\(.\)\(.\)', ]] ..
 | 
			
		||||
      [['\=submatch(0) . submatch(9) . submatch(8) . submatch(7) . ]] ..
 | 
			
		||||
@@ -110,7 +110,7 @@ describe('substitue()', function()
 | 
			
		||||
  -- #2943.
 | 
			
		||||
 | 
			
		||||
  it('with submatch or \\ze (TEST_7)', function()
 | 
			
		||||
    execute('set magic&')
 | 
			
		||||
    feed_command('set magic&')
 | 
			
		||||
    eq('A\rA', eval("substitute('A\rA', 'A.', '\\=submatch(0)', '')"))
 | 
			
		||||
    eq('B\nB', eval([[substitute("B\nB", 'B.', '\=submatch(0)', '')]]))
 | 
			
		||||
    eq("['B\n']B",
 | 
			
		||||
@@ -120,7 +120,7 @@ describe('substitue()', function()
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('with \\zs and \\ze (TEST_10)', function()
 | 
			
		||||
    execute('set magic&')
 | 
			
		||||
    feed_command('set magic&')
 | 
			
		||||
    eq('a1a2a3a', eval([[substitute('123', '\zs', 'a', 'g')]]))
 | 
			
		||||
    eq('aaa', eval([[substitute('123', '\zs.', 'a', 'g')]]))
 | 
			
		||||
    eq('1a2a3a', eval([[substitute('123', '.\zs', 'a', 'g')]]))
 | 
			
		||||
@@ -140,11 +140,11 @@ describe(':substitue', function()
 | 
			
		||||
      ,,X
 | 
			
		||||
      ,,Y
 | 
			
		||||
      ,,Z]])
 | 
			
		||||
    execute('set magic&')
 | 
			
		||||
    execute([[1s/\(^\|,\)\ze\(,\|X\)/\1N/g]])
 | 
			
		||||
    execute([[2s/\(^\|,\)\ze\(,\|Y\)/\1N/gc]])
 | 
			
		||||
    feed_command('set magic&')
 | 
			
		||||
    feed_command([[1s/\(^\|,\)\ze\(,\|X\)/\1N/g]])
 | 
			
		||||
    feed_command([[2s/\(^\|,\)\ze\(,\|Y\)/\1N/gc]])
 | 
			
		||||
    feed('a')  -- For the dialog of the previous :s command.
 | 
			
		||||
    execute([[3s/\(^\|,\)\ze\(,\|Z\)/\1N/gc]])
 | 
			
		||||
    feed_command([[3s/\(^\|,\)\ze\(,\|Z\)/\1N/gc]])
 | 
			
		||||
    feed('yy')  -- For the dialog of the previous :s command.
 | 
			
		||||
    expect([[
 | 
			
		||||
      N,,NX
 | 
			
		||||
@@ -154,8 +154,8 @@ describe(':substitue', function()
 | 
			
		||||
 | 
			
		||||
  it('with confirmation dialog (TEST_9)', function()
 | 
			
		||||
    insert('xxx')
 | 
			
		||||
    execute('set magic&')
 | 
			
		||||
    execute('s/x/X/gc')
 | 
			
		||||
    feed_command('set magic&')
 | 
			
		||||
    feed_command('s/x/X/gc')
 | 
			
		||||
    feed('yyq')  -- For the dialog of the previous :s command.
 | 
			
		||||
    expect('XXx')
 | 
			
		||||
  end)
 | 
			
		||||
 
 | 
			
		||||
@@ -2,7 +2,7 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear, feed, insert = helpers.clear, helpers.feed, helpers.insert
 | 
			
		||||
local execute, expect = helpers.execute, helpers.expect
 | 
			
		||||
local feed_command, expect = helpers.feed_command, helpers.expect
 | 
			
		||||
 | 
			
		||||
describe('coptions', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
@@ -16,14 +16,14 @@ describe('coptions', function()
 | 
			
		||||
      ccc two three four
 | 
			
		||||
      ddd yee yoo four]])
 | 
			
		||||
 | 
			
		||||
    execute('set cpo-=;')
 | 
			
		||||
    feed_command('set cpo-=;')
 | 
			
		||||
 | 
			
		||||
    feed('gg0tt;D')
 | 
			
		||||
    feed('j0fz;D')
 | 
			
		||||
    feed('j$Fy;D')
 | 
			
		||||
    feed('j$Ty;D')
 | 
			
		||||
 | 
			
		||||
    execute('set cpo+=;')
 | 
			
		||||
    feed_command('set cpo+=;')
 | 
			
		||||
 | 
			
		||||
    feed('j0tt;;D')
 | 
			
		||||
    feed('j$Ty;;D')
 | 
			
		||||
 
 | 
			
		||||
@@ -3,7 +3,7 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local feed, source = helpers.feed, helpers.source
 | 
			
		||||
local clear, execute, expect = helpers.clear, helpers.execute, helpers.expect
 | 
			
		||||
local clear, feed_command, expect = helpers.clear, helpers.feed_command, helpers.expect
 | 
			
		||||
 | 
			
		||||
describe('case-insensitive string comparison in UTF-8', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
@@ -106,11 +106,11 @@ describe('case-insensitive string comparison in UTF-8', function()
 | 
			
		||||
    ]])
 | 
			
		||||
 | 
			
		||||
    -- Test that g~ap changes one paragraph only.
 | 
			
		||||
    execute('new')
 | 
			
		||||
    feed_command('new')
 | 
			
		||||
    feed('iabcd<cr><cr>defg<esc>gg0g~ap')
 | 
			
		||||
    execute('let lns = getline(1,3)')
 | 
			
		||||
    execute('q!')
 | 
			
		||||
    execute([[call append(line('$'), lns)]])
 | 
			
		||||
    feed_command('let lns = getline(1,3)')
 | 
			
		||||
    feed_command('q!')
 | 
			
		||||
    feed_command([[call append(line('$'), lns)]])
 | 
			
		||||
 | 
			
		||||
    -- Assert buffer contents.
 | 
			
		||||
    expect([=[
 | 
			
		||||
 
 | 
			
		||||
@@ -2,8 +2,8 @@
 | 
			
		||||
-- tabulators.
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local feed, insert, clear, execute =
 | 
			
		||||
  helpers.feed, helpers.insert, helpers.clear, helpers.execute
 | 
			
		||||
local feed, insert, clear, feed_command =
 | 
			
		||||
  helpers.feed, helpers.insert, helpers.clear, helpers.feed_command
 | 
			
		||||
 | 
			
		||||
local expect_pos = function(row, col)
 | 
			
		||||
  return helpers.eq({row, col}, helpers.eval('[screenrow(), screencol()]'))
 | 
			
		||||
@@ -25,11 +25,11 @@ describe('cursor and column position with conceal and tabulators', function()
 | 
			
		||||
      |a|	|b|	|c|	|d|]])
 | 
			
		||||
 | 
			
		||||
    -- Conceal settings.
 | 
			
		||||
    execute('set conceallevel=2')
 | 
			
		||||
    execute('set concealcursor=nc')
 | 
			
		||||
    execute('syntax match test /|/ conceal')
 | 
			
		||||
    feed_command('set conceallevel=2')
 | 
			
		||||
    feed_command('set concealcursor=nc')
 | 
			
		||||
    feed_command('syntax match test /|/ conceal')
 | 
			
		||||
    -- Start test.
 | 
			
		||||
    execute('/^start:')
 | 
			
		||||
    feed_command('/^start:')
 | 
			
		||||
    feed('ztj')
 | 
			
		||||
    expect_pos(2, 1)
 | 
			
		||||
    -- We should end up in the same column when running these commands on the
 | 
			
		||||
@@ -78,10 +78,10 @@ describe('cursor and column position with conceal and tabulators', function()
 | 
			
		||||
    expect_pos(9, 25)
 | 
			
		||||
    feed('$')
 | 
			
		||||
    expect_pos(9, 26)
 | 
			
		||||
    execute('set lbr')
 | 
			
		||||
    feed_command('set lbr')
 | 
			
		||||
    feed('$')
 | 
			
		||||
    expect_pos(9, 26)
 | 
			
		||||
    execute('set list listchars=tab:>-')
 | 
			
		||||
    feed_command('set list listchars=tab:>-')
 | 
			
		||||
    feed('0')
 | 
			
		||||
    expect_pos(9, 1)
 | 
			
		||||
    feed('W')
 | 
			
		||||
 
 | 
			
		||||
@@ -5,7 +5,7 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local feed, insert = helpers.feed, helpers.insert
 | 
			
		||||
local clear, execute, expect = helpers.clear, helpers.execute, helpers.expect
 | 
			
		||||
local clear, feed_command, expect = helpers.clear, helpers.feed_command, helpers.expect
 | 
			
		||||
 | 
			
		||||
describe('store cursor position in session file in UTF-8', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
@@ -29,15 +29,15 @@ describe('store cursor position in session file in UTF-8', function()
 | 
			
		||||
    -- This test requires the buffer to correspond to a file on disk, here named
 | 
			
		||||
    -- "test.in", because otherwise :mksession won't write out the cursor column
 | 
			
		||||
    -- info needed for verification.
 | 
			
		||||
    execute('write! test.in')
 | 
			
		||||
    feed_command('write! test.in')
 | 
			
		||||
 | 
			
		||||
    execute('set sessionoptions=buffers splitbelow fileencoding=utf-8')
 | 
			
		||||
    feed_command('set sessionoptions=buffers splitbelow fileencoding=utf-8')
 | 
			
		||||
 | 
			
		||||
    -- Move the cursor through the buffer lines and position it with "|". Using
 | 
			
		||||
    -- :split after every normal mode command is a trick to have multiple
 | 
			
		||||
    -- cursors on the screen that can all be stored in the session file.
 | 
			
		||||
    execute('/^start:')
 | 
			
		||||
    execute('vsplit')
 | 
			
		||||
    feed_command('/^start:')
 | 
			
		||||
    feed_command('vsplit')
 | 
			
		||||
    feed('j16|:split<cr>')
 | 
			
		||||
    feed('j16|:split<cr>')
 | 
			
		||||
    feed('j16|:split<cr>')
 | 
			
		||||
@@ -49,9 +49,9 @@ describe('store cursor position in session file in UTF-8', function()
 | 
			
		||||
 | 
			
		||||
    -- Again move the cursor through the buffer and position it with "|". This
 | 
			
		||||
    -- time also perform a horizontal scroll at every step.
 | 
			
		||||
    execute('wincmd l')
 | 
			
		||||
    execute('/^start:')
 | 
			
		||||
    execute('set nowrap')
 | 
			
		||||
    feed_command('wincmd l')
 | 
			
		||||
    feed_command('/^start:')
 | 
			
		||||
    feed_command('set nowrap')
 | 
			
		||||
    feed('j16|3zl:split<cr>')
 | 
			
		||||
    feed('j016|3zl:split<cr>')
 | 
			
		||||
    feed('j016|3zl:split<cr>')
 | 
			
		||||
@@ -62,9 +62,9 @@ describe('store cursor position in session file in UTF-8', function()
 | 
			
		||||
    feed('j016|3zl:split<cr>')
 | 
			
		||||
 | 
			
		||||
    -- Create the session file, read it back in, and prepare for verification.
 | 
			
		||||
    execute('mksession! test.out')
 | 
			
		||||
    execute('new test.out')
 | 
			
		||||
    execute([[v/\(^ *normal! 0\|^ *exe 'normal!\)/d]])
 | 
			
		||||
    feed_command('mksession! test.out')
 | 
			
		||||
    feed_command('new test.out')
 | 
			
		||||
    feed_command([[v/\(^ *normal! 0\|^ *exe 'normal!\)/d]])
 | 
			
		||||
 | 
			
		||||
    -- Assert buffer contents.
 | 
			
		||||
    expect([[
 | 
			
		||||
 
 | 
			
		||||
@@ -5,7 +5,7 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local feed, insert = helpers.feed, helpers.insert
 | 
			
		||||
local clear, execute, expect = helpers.clear, helpers.execute, helpers.expect
 | 
			
		||||
local clear, feed_command, expect = helpers.clear, helpers.feed_command, helpers.expect
 | 
			
		||||
 | 
			
		||||
if helpers.pending_win32(pending) then return end
 | 
			
		||||
 | 
			
		||||
@@ -30,13 +30,13 @@ describe('store cursor position in session file in Latin-1', function()
 | 
			
		||||
      A<><41><EFBFBD>  three mulTibyte characters]])
 | 
			
		||||
    -- Must write buffer to disk for :mksession. See the comments in
 | 
			
		||||
    -- "092_mksession_cursor_cols_utf8_spec.lua".
 | 
			
		||||
    execute('write! test.in')
 | 
			
		||||
    feed_command('write! test.in')
 | 
			
		||||
 | 
			
		||||
    execute('set sessionoptions=buffers splitbelow fileencoding=latin1')
 | 
			
		||||
    feed_command('set sessionoptions=buffers splitbelow fileencoding=latin1')
 | 
			
		||||
 | 
			
		||||
    -- Move the cursor through the buffer lines and position it with "|".
 | 
			
		||||
    execute('/^start:')
 | 
			
		||||
    execute('vsplit')
 | 
			
		||||
    feed_command('/^start:')
 | 
			
		||||
    feed_command('vsplit')
 | 
			
		||||
    feed('j16|:split<cr>')
 | 
			
		||||
    feed('j16|:split<cr>')
 | 
			
		||||
    feed('j16|:split<cr>')
 | 
			
		||||
@@ -48,9 +48,9 @@ describe('store cursor position in session file in Latin-1', function()
 | 
			
		||||
 | 
			
		||||
    -- Again move the cursor through the buffer and position it with "|". This
 | 
			
		||||
    -- time also perform a horizontal scroll at every step.
 | 
			
		||||
    execute('wincmd l')
 | 
			
		||||
    execute('/^start:')
 | 
			
		||||
    execute('set nowrap')
 | 
			
		||||
    feed_command('wincmd l')
 | 
			
		||||
    feed_command('/^start:')
 | 
			
		||||
    feed_command('set nowrap')
 | 
			
		||||
    feed('j16|3zl:split<cr>')
 | 
			
		||||
    feed('j016|3zl:split<cr>')
 | 
			
		||||
    feed('j016|3zl:split<cr>')
 | 
			
		||||
@@ -61,9 +61,9 @@ describe('store cursor position in session file in Latin-1', function()
 | 
			
		||||
    feed('j016|3zl:split<cr>')
 | 
			
		||||
 | 
			
		||||
    -- Create the session file, read it back in, and prepare for verification.
 | 
			
		||||
    execute('mksession! test.out')
 | 
			
		||||
    execute('new test.out')
 | 
			
		||||
    execute([[v/\(^ *normal! 0\|^ *exe 'normal!\)/d]])
 | 
			
		||||
    feed_command('mksession! test.out')
 | 
			
		||||
    feed_command('new test.out')
 | 
			
		||||
    feed_command([[v/\(^ *normal! 0\|^ *exe 'normal!\)/d]])
 | 
			
		||||
 | 
			
		||||
    -- Assert buffer contents.
 | 
			
		||||
    expect([[
 | 
			
		||||
 
 | 
			
		||||
@@ -6,7 +6,7 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local feed, insert, source = helpers.feed, helpers.insert, helpers.source
 | 
			
		||||
local clear, execute, expect = helpers.clear, helpers.execute, helpers.expect
 | 
			
		||||
local clear, feed_command, expect = helpers.clear, helpers.feed_command, helpers.expect
 | 
			
		||||
 | 
			
		||||
-- Vim script user functions needed for some of the test cases.
 | 
			
		||||
local function source_user_functions()
 | 
			
		||||
@@ -68,15 +68,15 @@ describe('Visual mode and operator', function()
 | 
			
		||||
      xxxxxxxxxxxxx]])
 | 
			
		||||
 | 
			
		||||
    -- Exercise characterwise Visual mode plus operator, with count and repeat.
 | 
			
		||||
    execute('/^apple')
 | 
			
		||||
    feed_command('/^apple')
 | 
			
		||||
    feed('lvld.l3vd.')
 | 
			
		||||
 | 
			
		||||
    -- Same in linewise Visual mode.
 | 
			
		||||
    execute('/^line 1')
 | 
			
		||||
    feed_command('/^line 1')
 | 
			
		||||
    feed('Vcnewline<esc>j.j2Vd.')
 | 
			
		||||
 | 
			
		||||
    -- Same in blockwise Visual mode.
 | 
			
		||||
    execute('/^xxxx')
 | 
			
		||||
    feed_command('/^xxxx')
 | 
			
		||||
    feed('<c-v>jlc  <esc>l.l2<c-v>c----<esc>l.')
 | 
			
		||||
 | 
			
		||||
    -- Assert buffer contents.
 | 
			
		||||
@@ -98,15 +98,15 @@ describe('Visual mode and operator', function()
 | 
			
		||||
      JambuRambutanBananaTangerineMango]])
 | 
			
		||||
 | 
			
		||||
    -- Set up Visual mode mappings.
 | 
			
		||||
    execute('vnoremap W /\\u/s-1<CR>')
 | 
			
		||||
    execute('vnoremap iW :<C-U>call SelectInCaps()<CR>')
 | 
			
		||||
    feed_command('vnoremap W /\\u/s-1<CR>')
 | 
			
		||||
    feed_command('vnoremap iW :<C-U>call SelectInCaps()<CR>')
 | 
			
		||||
 | 
			
		||||
    -- Do a simple change using the simple vmap, also with count and repeat.
 | 
			
		||||
    execute('/^Kiwi')
 | 
			
		||||
    feed_command('/^Kiwi')
 | 
			
		||||
    feed('vWcNo<esc>l.fD2vd.')
 | 
			
		||||
 | 
			
		||||
    -- Same, using the vmap that maps to an Ex command.
 | 
			
		||||
    execute('/^Jambu')
 | 
			
		||||
    feed_command('/^Jambu')
 | 
			
		||||
    feed('llviWc-<esc>l.l2vdl.')
 | 
			
		||||
 | 
			
		||||
    -- Assert buffer contents.
 | 
			
		||||
@@ -122,20 +122,20 @@ describe('Visual mode and operator', function()
 | 
			
		||||
      LemonNectarineZ]])
 | 
			
		||||
 | 
			
		||||
    -- Set up Operator-pending mode mappings.
 | 
			
		||||
    execute('onoremap W /\\u/<CR>')
 | 
			
		||||
    execute('onoremap <Leader>W :<C-U>call MoveToCap()<CR>')
 | 
			
		||||
    execute('onoremap iW :<C-U>call SelectInCaps()<CR>')
 | 
			
		||||
    feed_command('onoremap W /\\u/<CR>')
 | 
			
		||||
    feed_command('onoremap <Leader>W :<C-U>call MoveToCap()<CR>')
 | 
			
		||||
    feed_command('onoremap iW :<C-U>call SelectInCaps()<CR>')
 | 
			
		||||
 | 
			
		||||
    -- Do a simple change using the simple omap, also with count and repeat.
 | 
			
		||||
    execute('/^Pineapple')
 | 
			
		||||
    feed_command('/^Pineapple')
 | 
			
		||||
    feed('cW-<esc>l.l2.l.')
 | 
			
		||||
 | 
			
		||||
    -- Same, using the omap that maps to an Ex command to move the cursor.
 | 
			
		||||
    execute('/^Juniper')
 | 
			
		||||
    feed_command('/^Juniper')
 | 
			
		||||
    feed('g?\\WfD.')
 | 
			
		||||
 | 
			
		||||
    -- Same, using the omap that uses Ex and Visual mode (custom text object).
 | 
			
		||||
    execute('/^Lemon')
 | 
			
		||||
    feed_command('/^Lemon')
 | 
			
		||||
    feed('yiWPlciWNew<esc>fr.')
 | 
			
		||||
 | 
			
		||||
    -- Assert buffer contents.
 | 
			
		||||
@@ -159,7 +159,7 @@ describe('Visual mode and operator', function()
 | 
			
		||||
    --   changed, taking into account the v/V/<c-v> modifier given; or
 | 
			
		||||
    -- - abort the operation by pressing Escape: no change to the buffer is
 | 
			
		||||
    --   carried out.
 | 
			
		||||
    execute('/^zzzz')
 | 
			
		||||
    feed_command('/^zzzz')
 | 
			
		||||
    feed([[dV:<cr>dv:<cr>:set noma | let v:errmsg = ''<cr>]])
 | 
			
		||||
    feed([[d:<cr>:set ma | put = v:errmsg =~# '^E21' ? 'ok' : 'failed'<cr>]])
 | 
			
		||||
    feed([[dv:<esc>dV:<esc>:set noma | let v:errmsg = ''<cr>]])
 | 
			
		||||
@@ -318,7 +318,7 @@ describe('Visual mode and operator', function()
 | 
			
		||||
  describe('v_p:', function()
 | 
			
		||||
    it('replace last character with line register at middle line', function()
 | 
			
		||||
      put_aaabbbccc()
 | 
			
		||||
      execute('-2yank')
 | 
			
		||||
      feed_command('-2yank')
 | 
			
		||||
      feed('k$vp')
 | 
			
		||||
 | 
			
		||||
      expect([[
 | 
			
		||||
@@ -332,7 +332,7 @@ describe('Visual mode and operator', function()
 | 
			
		||||
 | 
			
		||||
    it('replace last character with line register at middle line selecting newline', function()
 | 
			
		||||
      put_aaabbbccc()
 | 
			
		||||
      execute('-2yank')
 | 
			
		||||
      feed_command('-2yank')
 | 
			
		||||
      feed('k$v$p')
 | 
			
		||||
 | 
			
		||||
      expect([[
 | 
			
		||||
@@ -345,7 +345,7 @@ describe('Visual mode and operator', function()
 | 
			
		||||
 | 
			
		||||
    it('replace last character with line register at last line', function()
 | 
			
		||||
      put_aaabbbccc()
 | 
			
		||||
      execute('-2yank')
 | 
			
		||||
      feed_command('-2yank')
 | 
			
		||||
      feed('$vp')
 | 
			
		||||
 | 
			
		||||
      expect([[
 | 
			
		||||
@@ -359,7 +359,7 @@ describe('Visual mode and operator', function()
 | 
			
		||||
 | 
			
		||||
    it('replace last character with line register at last line selecting newline', function()
 | 
			
		||||
      put_aaabbbccc()
 | 
			
		||||
      execute('-2yank')
 | 
			
		||||
      feed_command('-2yank')
 | 
			
		||||
      feed('$v$p')
 | 
			
		||||
 | 
			
		||||
      expect([[
 | 
			
		||||
 
 | 
			
		||||
@@ -8,7 +8,7 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local source = helpers.source
 | 
			
		||||
local clear, execute, expect = helpers.clear, helpers.execute, helpers.expect
 | 
			
		||||
local clear, command, expect = helpers.clear, helpers.command, helpers.expect
 | 
			
		||||
 | 
			
		||||
describe('location list', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
@@ -71,74 +71,74 @@ describe('location list', function()
 | 
			
		||||
    ]])
 | 
			
		||||
 | 
			
		||||
    -- Set up the result buffer "test.out".
 | 
			
		||||
    execute('enew')
 | 
			
		||||
    execute('w! test.out')
 | 
			
		||||
    execute('b 1')
 | 
			
		||||
    command('enew')
 | 
			
		||||
    command('w! test.out')
 | 
			
		||||
    command('b 1')
 | 
			
		||||
 | 
			
		||||
    -- Test A.
 | 
			
		||||
 | 
			
		||||
    -- Open a new buffer as the sole window, rewind and open the prepopulated
 | 
			
		||||
    -- location list and navigate through the entries.
 | 
			
		||||
    execute('lrewind')
 | 
			
		||||
    execute('enew')
 | 
			
		||||
    execute('lopen')
 | 
			
		||||
    execute('lnext', 'lnext', 'lnext', 'lnext')
 | 
			
		||||
    command('lrewind')
 | 
			
		||||
    command('enew')
 | 
			
		||||
    command('lopen')
 | 
			
		||||
    command('lnext', 'lnext', 'lnext', 'lnext')
 | 
			
		||||
 | 
			
		||||
    -- Split the window, copying the location list, then open the copied
 | 
			
		||||
    -- location list and again navigate forward.
 | 
			
		||||
    execute('vert split')
 | 
			
		||||
    execute('wincmd L')
 | 
			
		||||
    execute('lopen')
 | 
			
		||||
    execute('wincmd p')
 | 
			
		||||
    execute('lnext')
 | 
			
		||||
    command('vert split')
 | 
			
		||||
    command('wincmd L')
 | 
			
		||||
    command('lopen')
 | 
			
		||||
    command('wincmd p')
 | 
			
		||||
    command('lnext')
 | 
			
		||||
 | 
			
		||||
    -- Record the current file name and the file name of the corresponding
 | 
			
		||||
    -- location list entry, then open the result buffer.
 | 
			
		||||
    execute('let fileName = expand("%")')
 | 
			
		||||
    execute('wincmd p')
 | 
			
		||||
    execute([[let locationListFileName = substitute(getline(line('.')), '\([^|]*\)|.*', '\1', '')]])
 | 
			
		||||
    execute('wincmd n')
 | 
			
		||||
    execute('wincmd K')
 | 
			
		||||
    execute('b test.out')
 | 
			
		||||
    command('let fileName = expand("%")')
 | 
			
		||||
    command('wincmd p')
 | 
			
		||||
    command([[let locationListFileName = substitute(getline(line('.')), '\([^|]*\)|.*', '\1', '')]])
 | 
			
		||||
    command('wincmd n')
 | 
			
		||||
    command('wincmd K')
 | 
			
		||||
    command('b test.out')
 | 
			
		||||
 | 
			
		||||
    -- Prepare test output and write it to the result buffer.
 | 
			
		||||
    execute([[let fileName = substitute(fileName, '\\', '/', 'g')]])
 | 
			
		||||
    execute([[let locationListFileName = substitute(locationListFileName, '\\', '/', 'g')]])
 | 
			
		||||
    execute([[call append(line('$'), "Test A:")]])
 | 
			
		||||
    execute([[call append(line('$'), "  - file name displayed: " . fileName)]])
 | 
			
		||||
    execute([[call append(line('$'), "  - quickfix claims that the file name displayed is: " . locationListFileName)]])
 | 
			
		||||
    execute('w')
 | 
			
		||||
    command([[let fileName = substitute(fileName, '\\', '/', 'g')]])
 | 
			
		||||
    command([[let locationListFileName = substitute(locationListFileName, '\\', '/', 'g')]])
 | 
			
		||||
    command([[call append(line('$'), "Test A:")]])
 | 
			
		||||
    command([[call append(line('$'), "  - file name displayed: " . fileName)]])
 | 
			
		||||
    command([[call append(line('$'), "  - quickfix claims that the file name displayed is: " . locationListFileName)]])
 | 
			
		||||
    command('w')
 | 
			
		||||
 | 
			
		||||
    -- Clean slate for the next test.
 | 
			
		||||
    execute('wincmd o')
 | 
			
		||||
    execute('b 1')
 | 
			
		||||
    command('wincmd o')
 | 
			
		||||
    command('b 1')
 | 
			
		||||
 | 
			
		||||
    -- Test B.
 | 
			
		||||
 | 
			
		||||
    -- Rewind the location list, then open it and browse through it by running
 | 
			
		||||
    -- ":{number}" followed by Enter repeatedly in the location list window.
 | 
			
		||||
    execute('lrewind')
 | 
			
		||||
    execute('lopen')
 | 
			
		||||
    execute('2', [[exe "normal \\<CR>"]])
 | 
			
		||||
    execute('wincmd p')
 | 
			
		||||
    execute('3', [[exe "normal \<CR>"]])
 | 
			
		||||
    execute('wincmd p')
 | 
			
		||||
    execute('4', [[exe "normal \<CR>"]])
 | 
			
		||||
    command('lrewind')
 | 
			
		||||
    command('lopen')
 | 
			
		||||
    command('2', [[exe "normal \\<CR>"]])
 | 
			
		||||
    command('wincmd p')
 | 
			
		||||
    command('3', [[exe "normal \<CR>"]])
 | 
			
		||||
    command('wincmd p')
 | 
			
		||||
    command('4', [[exe "normal \<CR>"]])
 | 
			
		||||
 | 
			
		||||
    -- Record the number of windows open, then go back to the result buffer.
 | 
			
		||||
    execute('let numberOfWindowsOpen = winnr("$")')
 | 
			
		||||
    execute('wincmd n')
 | 
			
		||||
    execute('wincmd K')
 | 
			
		||||
    execute('b test.out')
 | 
			
		||||
    command('let numberOfWindowsOpen = winnr("$")')
 | 
			
		||||
    command('wincmd n')
 | 
			
		||||
    command('wincmd K')
 | 
			
		||||
    command('b test.out')
 | 
			
		||||
 | 
			
		||||
    -- Prepare test output and write it to the result buffer.
 | 
			
		||||
    execute('call append(line("$"), "Test B:")')
 | 
			
		||||
    execute('call append(line("$"), "  - number of window open: " . numberOfWindowsOpen)')
 | 
			
		||||
    execute('w')
 | 
			
		||||
    command('call append(line("$"), "Test B:")')
 | 
			
		||||
    command('call append(line("$"), "  - number of window open: " . numberOfWindowsOpen)')
 | 
			
		||||
    command('w')
 | 
			
		||||
 | 
			
		||||
    -- Clean slate.
 | 
			
		||||
    execute('wincmd o')
 | 
			
		||||
    execute('b 1')
 | 
			
		||||
    command('wincmd o')
 | 
			
		||||
    command('b 1')
 | 
			
		||||
 | 
			
		||||
    -- Test C.
 | 
			
		||||
 | 
			
		||||
@@ -146,34 +146,34 @@ describe('location list', function()
 | 
			
		||||
    -- Enter browsing. But this time, move the location list window to the top
 | 
			
		||||
    -- to check whether it (the first window found) will be reused when we try
 | 
			
		||||
    -- to open new windows.
 | 
			
		||||
    execute('lrewind')
 | 
			
		||||
    execute('lopen')
 | 
			
		||||
    execute('wincmd K')
 | 
			
		||||
    execute('2', [[exe "normal \<CR>"]])
 | 
			
		||||
    execute('wincmd p')
 | 
			
		||||
    execute('3', [[exe "normal \<CR>"]])
 | 
			
		||||
    execute('wincmd p')
 | 
			
		||||
    execute('4', [[exe "normal \<CR>"]])
 | 
			
		||||
    command('lrewind')
 | 
			
		||||
    command('lopen')
 | 
			
		||||
    command('wincmd K')
 | 
			
		||||
    command('2', [[exe "normal \<CR>"]])
 | 
			
		||||
    command('wincmd p')
 | 
			
		||||
    command('3', [[exe "normal \<CR>"]])
 | 
			
		||||
    command('wincmd p')
 | 
			
		||||
    command('4', [[exe "normal \<CR>"]])
 | 
			
		||||
 | 
			
		||||
    -- Record the 'buftype' of window 1 (the location list) and the buffer name
 | 
			
		||||
    -- of window 2 (the current "test protocol" buffer), then go back to the
 | 
			
		||||
    -- result buffer.
 | 
			
		||||
    execute('1wincmd w')
 | 
			
		||||
    execute('let locationListWindowBufType = &buftype')
 | 
			
		||||
    execute('2wincmd w')
 | 
			
		||||
    execute('let bufferName = expand("%")')
 | 
			
		||||
    execute('wincmd n')
 | 
			
		||||
    execute('wincmd K')
 | 
			
		||||
    execute('b test.out')
 | 
			
		||||
    command('1wincmd w')
 | 
			
		||||
    command('let locationListWindowBufType = &buftype')
 | 
			
		||||
    command('2wincmd w')
 | 
			
		||||
    command('let bufferName = expand("%")')
 | 
			
		||||
    command('wincmd n')
 | 
			
		||||
    command('wincmd K')
 | 
			
		||||
    command('b test.out')
 | 
			
		||||
 | 
			
		||||
    -- Prepare test output and write it to the result buffer.
 | 
			
		||||
    execute([[let bufferName = substitute(bufferName, '\\', '/', 'g')]])
 | 
			
		||||
    execute([[call append(line("$"), "Test C:")]])
 | 
			
		||||
    execute([[call append(line('$'), "  - 'buftype' of the location list window: " . locationListWindowBufType)]])
 | 
			
		||||
    execute([[call append(line('$'), "  - buffer displayed in the 2nd window: " . bufferName)]])
 | 
			
		||||
    execute('w')
 | 
			
		||||
    execute('wincmd o')
 | 
			
		||||
    execute('b 1')
 | 
			
		||||
    command([[let bufferName = substitute(bufferName, '\\', '/', 'g')]])
 | 
			
		||||
    command([[call append(line("$"), "Test C:")]])
 | 
			
		||||
    command([[call append(line('$'), "  - 'buftype' of the location list window: " . locationListWindowBufType)]])
 | 
			
		||||
    command([[call append(line('$'), "  - buffer displayed in the 2nd window: " . bufferName)]])
 | 
			
		||||
    command('w')
 | 
			
		||||
    command('wincmd o')
 | 
			
		||||
    command('b 1')
 | 
			
		||||
 | 
			
		||||
    -- Assert buffer contents.
 | 
			
		||||
    expect([[
 | 
			
		||||
 
 | 
			
		||||
@@ -4,7 +4,7 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear = helpers.clear
 | 
			
		||||
local execute, expect = helpers.execute, helpers.expect
 | 
			
		||||
local command, expect = helpers.command, helpers.expect
 | 
			
		||||
 | 
			
		||||
if helpers.pending_win32(pending) then return end
 | 
			
		||||
 | 
			
		||||
@@ -19,21 +19,21 @@ describe('glob() and globpath()', function()
 | 
			
		||||
 | 
			
		||||
  it('is working', function()
 | 
			
		||||
    -- Make sure glob() doesn't use the shell
 | 
			
		||||
    execute('set shell=doesnotexist')
 | 
			
		||||
    command('set shell=doesnotexist')
 | 
			
		||||
 | 
			
		||||
    -- Consistent sorting of file names
 | 
			
		||||
    execute('set nofileignorecase')
 | 
			
		||||
    command('set nofileignorecase')
 | 
			
		||||
 | 
			
		||||
    execute([[$put =glob('Xxx\{')]])
 | 
			
		||||
    execute([[$put =glob('Xxx\$')]])
 | 
			
		||||
    command([[$put =glob('Xxx\{')]])
 | 
			
		||||
    command([[$put =glob('Xxx\$')]])
 | 
			
		||||
 | 
			
		||||
    execute('w! Xxx{')
 | 
			
		||||
    execute([[w! Xxx\$]])
 | 
			
		||||
    execute([[$put =glob('Xxx\{')]])
 | 
			
		||||
    execute([[$put =glob('Xxx\$')]])
 | 
			
		||||
    command('w! Xxx{')
 | 
			
		||||
    command([[w! Xxx\$]])
 | 
			
		||||
    command([[$put =glob('Xxx\{')]])
 | 
			
		||||
    command([[$put =glob('Xxx\$')]])
 | 
			
		||||
 | 
			
		||||
    execute("$put =string(globpath('sautest/autoload', '*.vim'))")
 | 
			
		||||
    execute("$put =string(globpath('sautest/autoload', '*.vim', 0, 1))")
 | 
			
		||||
    command("$put =string(globpath('sautest/autoload', '*.vim'))")
 | 
			
		||||
    command("$put =string(globpath('sautest/autoload', '*.vim', 0, 1))")
 | 
			
		||||
 | 
			
		||||
    expect([=[
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
@@ -2,52 +2,52 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear, feed = helpers.clear, helpers.feed
 | 
			
		||||
local execute, expect = helpers.execute, helpers.expect
 | 
			
		||||
local feed_command, expect = helpers.feed_command, helpers.expect
 | 
			
		||||
 | 
			
		||||
describe('v:hlsearch', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
 | 
			
		||||
  it('is working', function()
 | 
			
		||||
    -- Last abc: Q
 | 
			
		||||
    execute('new')
 | 
			
		||||
    execute([[call setline(1, repeat(['aaa'], 10))]])
 | 
			
		||||
    execute('set hlsearch nolazyredraw')
 | 
			
		||||
    execute('let r=[]')
 | 
			
		||||
    execute('command -nargs=0 -bar AddR :call add(r, [screenattr(1, 1), v:hlsearch])')
 | 
			
		||||
    execute('/aaa')
 | 
			
		||||
    execute('AddR')
 | 
			
		||||
    execute('nohlsearch')
 | 
			
		||||
    execute('AddR')
 | 
			
		||||
    execute('let v:hlsearch=1')
 | 
			
		||||
    execute('AddR')
 | 
			
		||||
    execute('let v:hlsearch=0')
 | 
			
		||||
    execute('AddR')
 | 
			
		||||
    execute('set hlsearch')
 | 
			
		||||
    execute('AddR')
 | 
			
		||||
    execute('let v:hlsearch=0')
 | 
			
		||||
    execute('AddR')
 | 
			
		||||
    feed_command('new')
 | 
			
		||||
    feed_command([[call setline(1, repeat(['aaa'], 10))]])
 | 
			
		||||
    feed_command('set hlsearch nolazyredraw')
 | 
			
		||||
    feed_command('let r=[]')
 | 
			
		||||
    feed_command('command -nargs=0 -bar AddR :call add(r, [screenattr(1, 1), v:hlsearch])')
 | 
			
		||||
    feed_command('/aaa')
 | 
			
		||||
    feed_command('AddR')
 | 
			
		||||
    feed_command('nohlsearch')
 | 
			
		||||
    feed_command('AddR')
 | 
			
		||||
    feed_command('let v:hlsearch=1')
 | 
			
		||||
    feed_command('AddR')
 | 
			
		||||
    feed_command('let v:hlsearch=0')
 | 
			
		||||
    feed_command('AddR')
 | 
			
		||||
    feed_command('set hlsearch')
 | 
			
		||||
    feed_command('AddR')
 | 
			
		||||
    feed_command('let v:hlsearch=0')
 | 
			
		||||
    feed_command('AddR')
 | 
			
		||||
    feed('n:AddR<cr>')
 | 
			
		||||
    execute('let v:hlsearch=0')
 | 
			
		||||
    execute('AddR')
 | 
			
		||||
    execute('/')
 | 
			
		||||
    execute('AddR')
 | 
			
		||||
    execute('set nohls')
 | 
			
		||||
    execute('/')
 | 
			
		||||
    execute('AddR')
 | 
			
		||||
    execute('let r1=r[0][0]')
 | 
			
		||||
    feed_command('let v:hlsearch=0')
 | 
			
		||||
    feed_command('AddR')
 | 
			
		||||
    feed_command('/')
 | 
			
		||||
    feed_command('AddR')
 | 
			
		||||
    feed_command('set nohls')
 | 
			
		||||
    feed_command('/')
 | 
			
		||||
    feed_command('AddR')
 | 
			
		||||
    feed_command('let r1=r[0][0]')
 | 
			
		||||
 | 
			
		||||
    -- I guess it is not guaranteed that screenattr outputs always the same character
 | 
			
		||||
    execute([[call map(r, 'v:val[1].":".(v:val[0]==r1?"highlighted":"not highlighted")')]])
 | 
			
		||||
    execute('try')
 | 
			
		||||
    execute('   let v:hlsearch=[]')
 | 
			
		||||
    execute('catch')
 | 
			
		||||
    execute([[   call add(r, matchstr(v:exception,'^Vim(let):E\d\+:'))]])
 | 
			
		||||
    execute('endtry')
 | 
			
		||||
    execute('bwipeout!')
 | 
			
		||||
    execute('$put=r')
 | 
			
		||||
    execute('call garbagecollect(1)')
 | 
			
		||||
    execute('call getchar()')
 | 
			
		||||
    execute('1d', '1d')
 | 
			
		||||
    feed_command([[call map(r, 'v:val[1].":".(v:val[0]==r1?"highlighted":"not highlighted")')]])
 | 
			
		||||
    feed_command('try')
 | 
			
		||||
    feed_command('   let v:hlsearch=[]')
 | 
			
		||||
    feed_command('catch')
 | 
			
		||||
    feed_command([[   call add(r, matchstr(v:exception,'^Vim(let):E\d\+:'))]])
 | 
			
		||||
    feed_command('endtry')
 | 
			
		||||
    feed_command('bwipeout!')
 | 
			
		||||
    feed_command('$put=r')
 | 
			
		||||
    feed_command('call garbagecollect(1)')
 | 
			
		||||
    feed_command('call getchar()')
 | 
			
		||||
    feed_command('1d', '1d')
 | 
			
		||||
 | 
			
		||||
    -- Assert buffer contents.
 | 
			
		||||
    expect([[
 | 
			
		||||
 
 | 
			
		||||
@@ -2,16 +2,16 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear = helpers.clear
 | 
			
		||||
local execute, expect = helpers.execute, helpers.expect
 | 
			
		||||
local command, expect = helpers.command, helpers.expect
 | 
			
		||||
 | 
			
		||||
describe('fnameescape', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
 | 
			
		||||
  it('is working', function()
 | 
			
		||||
    execute('let fname = "Xspa ce"')
 | 
			
		||||
    execute('try', 'exe "w! " . fnameescape(fname)', "put='Space'", 'endtry')
 | 
			
		||||
    execute('let fname = "Xemark!"')
 | 
			
		||||
    execute('try', 'exe "w! " . fnameescape(fname)', "put='ExclamationMark'", 'endtry')
 | 
			
		||||
    command('let fname = "Xspa ce"')
 | 
			
		||||
    command('try | exe "w! " . fnameescape(fname) | put=\'Space\' | endtry')
 | 
			
		||||
    command('let fname = "Xemark!"')
 | 
			
		||||
    command('try | exe "w! " . fnameescape(fname) | put=\'ExclamationMark\' | endtry')
 | 
			
		||||
 | 
			
		||||
    expect([[
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
@@ -2,13 +2,13 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear, source = helpers.clear, helpers.source
 | 
			
		||||
local execute, expect = helpers.execute, helpers.expect
 | 
			
		||||
local command, expect = helpers.command, helpers.expect
 | 
			
		||||
 | 
			
		||||
describe(':let', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
 | 
			
		||||
  it('is working', function()
 | 
			
		||||
    execute('set runtimepath+=test/functional/fixtures')
 | 
			
		||||
    command('set runtimepath+=test/functional/fixtures')
 | 
			
		||||
 | 
			
		||||
    -- Test to not autoload when assigning.  It causes internal error.
 | 
			
		||||
    source([[
 | 
			
		||||
@@ -34,7 +34,7 @@ describe(':let', function()
 | 
			
		||||
      endfor]])
 | 
			
		||||
 | 
			
		||||
    -- Remove empty line
 | 
			
		||||
    execute('1d')
 | 
			
		||||
    command('1d')
 | 
			
		||||
 | 
			
		||||
    -- Assert buffer contents.
 | 
			
		||||
    expect([[
 | 
			
		||||
 
 | 
			
		||||
@@ -2,19 +2,19 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear = helpers.clear
 | 
			
		||||
local execute, expect = helpers.execute, helpers.expect
 | 
			
		||||
local command, expect = helpers.command, helpers.expect
 | 
			
		||||
 | 
			
		||||
describe('errorformat', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
 | 
			
		||||
  it('is working', function()
 | 
			
		||||
    execute("set efm=%EEEE%m,%WWWW%m,%+CCCC%.%#,%-GGGG%.%#")
 | 
			
		||||
    execute("cgetexpr ['WWWW', 'EEEE', 'CCCC']")
 | 
			
		||||
    execute("$put =strtrans(string(map(getqflist(), '[v:val.text, v:val.valid]')))")
 | 
			
		||||
    execute("cgetexpr ['WWWW', 'GGGG', 'EEEE', 'CCCC']")
 | 
			
		||||
    execute("$put =strtrans(string(map(getqflist(), '[v:val.text, v:val.valid]')))")
 | 
			
		||||
    execute("cgetexpr ['WWWW', 'GGGG', 'ZZZZ', 'EEEE', 'CCCC', 'YYYY']")
 | 
			
		||||
    execute("$put =strtrans(string(map(getqflist(), '[v:val.text, v:val.valid]')))")
 | 
			
		||||
    command("set efm=%EEEE%m,%WWWW%m,%+CCCC%.%#,%-GGGG%.%#")
 | 
			
		||||
    command("cgetexpr ['WWWW', 'EEEE', 'CCCC']")
 | 
			
		||||
    command("$put =strtrans(string(map(getqflist(), '[v:val.text, v:val.valid]')))")
 | 
			
		||||
    command("cgetexpr ['WWWW', 'GGGG', 'EEEE', 'CCCC']")
 | 
			
		||||
    command("$put =strtrans(string(map(getqflist(), '[v:val.text, v:val.valid]')))")
 | 
			
		||||
    command("cgetexpr ['WWWW', 'GGGG', 'ZZZZ', 'EEEE', 'CCCC', 'YYYY']")
 | 
			
		||||
    command("$put =strtrans(string(map(getqflist(), '[v:val.text, v:val.valid]')))")
 | 
			
		||||
    
 | 
			
		||||
    expect([=[
 | 
			
		||||
      
 | 
			
		||||
 
 | 
			
		||||
@@ -2,8 +2,11 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local Screen = require('test.functional.ui.screen')
 | 
			
		||||
 | 
			
		||||
local wait = helpers.wait
 | 
			
		||||
local clear = helpers.clear
 | 
			
		||||
local insert = helpers.insert
 | 
			
		||||
local clear, execute = helpers.clear, helpers.execute
 | 
			
		||||
local command = helpers.command
 | 
			
		||||
 | 
			
		||||
if helpers.pending_win32(pending) then return end
 | 
			
		||||
 | 
			
		||||
@@ -15,31 +18,32 @@ describe('107', function()
 | 
			
		||||
    screen:attach()
 | 
			
		||||
 | 
			
		||||
    insert('start:')
 | 
			
		||||
    execute('new')
 | 
			
		||||
    execute('call setline(1, range(1,256))')
 | 
			
		||||
    execute('let r=[]')
 | 
			
		||||
    execute('func! GetScreenStr(row)')
 | 
			
		||||
    execute('   let str = ""')
 | 
			
		||||
    execute('   for c in range(1,3)')
 | 
			
		||||
    execute('       let str .= nr2char(screenchar(a:row, c))')
 | 
			
		||||
    execute('   endfor')
 | 
			
		||||
    execute('   return str')
 | 
			
		||||
    execute('endfunc')
 | 
			
		||||
    execute([[exe ":norm! \<C-W>t\<C-W>=1Gzt\<C-W>w\<C-W>+"]])
 | 
			
		||||
    execute('let s3=GetScreenStr(1)')
 | 
			
		||||
    execute('wincmd p')
 | 
			
		||||
    execute('call add(r, [line("w0"), s3])')
 | 
			
		||||
    execute([[exe ":norm! \<C-W>t\<C-W>=50Gzt\<C-W>w\<C-W>+"]])
 | 
			
		||||
    execute('let s3=GetScreenStr(1)')
 | 
			
		||||
    execute('wincmd p')
 | 
			
		||||
    execute('call add(r, [line("w0"), s3])')
 | 
			
		||||
    execute([[exe ":norm! \<C-W>t\<C-W>=59Gzt\<C-W>w\<C-W>+"]])
 | 
			
		||||
    execute('let s3=GetScreenStr(1)')
 | 
			
		||||
    execute(':wincmd p')
 | 
			
		||||
    execute('call add(r, [line("w0"), s3])')
 | 
			
		||||
    execute('bwipeout!')
 | 
			
		||||
    execute('$put=r')
 | 
			
		||||
    execute('call garbagecollect(1)')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('new')
 | 
			
		||||
    command('call setline(1, range(1,256))')
 | 
			
		||||
    command('let r=[]')
 | 
			
		||||
    command('func! GetScreenStr(row)')
 | 
			
		||||
    command('   let str = ""')
 | 
			
		||||
    command('   for c in range(1,3)')
 | 
			
		||||
    command('       let str .= nr2char(screenchar(a:row, c))')
 | 
			
		||||
    command('   endfor')
 | 
			
		||||
    command('   return str')
 | 
			
		||||
    command('endfunc')
 | 
			
		||||
    command([[exe ":norm! \<C-W>t\<C-W>=1Gzt\<C-W>w\<C-W>+"]])
 | 
			
		||||
    command('let s3=GetScreenStr(1)')
 | 
			
		||||
    command('wincmd p')
 | 
			
		||||
    command('call add(r, [line("w0"), s3])')
 | 
			
		||||
    command([[exe ":norm! \<C-W>t\<C-W>=50Gzt\<C-W>w\<C-W>+"]])
 | 
			
		||||
    command('let s3=GetScreenStr(1)')
 | 
			
		||||
    command('wincmd p')
 | 
			
		||||
    command('call add(r, [line("w0"), s3])')
 | 
			
		||||
    command([[exe ":norm! \<C-W>t\<C-W>=59Gzt\<C-W>w\<C-W>+"]])
 | 
			
		||||
    command('let s3=GetScreenStr(1)')
 | 
			
		||||
    command(':wincmd p')
 | 
			
		||||
    command('call add(r, [line("w0"), s3])')
 | 
			
		||||
    command('bwipeout!')
 | 
			
		||||
    command('$put=r')
 | 
			
		||||
    command('call garbagecollect(1)')
 | 
			
		||||
 | 
			
		||||
    screen:expect([[
 | 
			
		||||
      start:                                               |
 | 
			
		||||
 
 | 
			
		||||
@@ -2,32 +2,32 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local feed, clear = helpers.feed, helpers.clear
 | 
			
		||||
local execute, expect = helpers.execute, helpers.expect
 | 
			
		||||
local feed_command, expect = helpers.feed_command, helpers.expect
 | 
			
		||||
 | 
			
		||||
describe('108', function()
 | 
			
		||||
  before_each(clear)
 | 
			
		||||
 | 
			
		||||
  it('is working', function()
 | 
			
		||||
    execute('lang mess C')
 | 
			
		||||
    execute('function! Foo()')
 | 
			
		||||
    execute('   let var1 = 1')
 | 
			
		||||
    execute('   let var2 = Bar(var1) + 9')
 | 
			
		||||
    execute('   return var2')
 | 
			
		||||
    execute('endfunction')
 | 
			
		||||
    execute('function! Bar(var)')
 | 
			
		||||
    execute('    let var1 = 2 + a:var')
 | 
			
		||||
    execute('    let var2 = Bazz(var1) + 4')
 | 
			
		||||
    execute('    return var2')
 | 
			
		||||
    execute('endfunction')
 | 
			
		||||
    execute('function! Bazz(var)')
 | 
			
		||||
    execute('    let var1 = 3 + a:var')
 | 
			
		||||
    execute('    let var3 = "another var"')
 | 
			
		||||
    execute('    return var1')
 | 
			
		||||
    execute('endfunction')
 | 
			
		||||
    execute('new')
 | 
			
		||||
    execute('debuggreedy')
 | 
			
		||||
    execute('redir => out')
 | 
			
		||||
    execute('debug echo Foo()')
 | 
			
		||||
    feed_command('lang mess C')
 | 
			
		||||
    feed_command('function! Foo()')
 | 
			
		||||
    feed_command('   let var1 = 1')
 | 
			
		||||
    feed_command('   let var2 = Bar(var1) + 9')
 | 
			
		||||
    feed_command('   return var2')
 | 
			
		||||
    feed_command('endfunction')
 | 
			
		||||
    feed_command('function! Bar(var)')
 | 
			
		||||
    feed_command('    let var1 = 2 + a:var')
 | 
			
		||||
    feed_command('    let var2 = Bazz(var1) + 4')
 | 
			
		||||
    feed_command('    return var2')
 | 
			
		||||
    feed_command('endfunction')
 | 
			
		||||
    feed_command('function! Bazz(var)')
 | 
			
		||||
    feed_command('    let var1 = 3 + a:var')
 | 
			
		||||
    feed_command('    let var3 = "another var"')
 | 
			
		||||
    feed_command('    return var1')
 | 
			
		||||
    feed_command('endfunction')
 | 
			
		||||
    feed_command('new')
 | 
			
		||||
    feed_command('debuggreedy')
 | 
			
		||||
    feed_command('redir => out')
 | 
			
		||||
    feed_command('debug echo Foo()')
 | 
			
		||||
    feed('step<cr>')
 | 
			
		||||
    feed('step<cr>')
 | 
			
		||||
    feed('step<cr>')
 | 
			
		||||
@@ -83,9 +83,9 @@ describe('108', function()
 | 
			
		||||
    feed('fram<cr>')
 | 
			
		||||
    feed([[echo "\n- final result 19:"<cr>]])
 | 
			
		||||
    feed('cont<cr>')
 | 
			
		||||
    execute('0debuggreedy')
 | 
			
		||||
    execute('redir END')
 | 
			
		||||
    execute('$put =out')
 | 
			
		||||
    feed_command('0debuggreedy')
 | 
			
		||||
    feed_command('redir END')
 | 
			
		||||
    feed_command('$put =out')
 | 
			
		||||
 | 
			
		||||
    -- Assert buffer contents.
 | 
			
		||||
    expect([=[
 | 
			
		||||
 
 | 
			
		||||
@@ -1,7 +1,7 @@
 | 
			
		||||
-- Test argument list commands
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear, execute, eq = helpers.clear, helpers.execute, helpers.eq
 | 
			
		||||
local clear, command, eq = helpers.clear, helpers.command, helpers.eq
 | 
			
		||||
local eval, exc_exec, neq = helpers.eval, helpers.exc_exec, helpers.neq
 | 
			
		||||
 | 
			
		||||
if helpers.pending_win32(pending) then return end
 | 
			
		||||
@@ -10,12 +10,12 @@ describe('argument list commands', function()
 | 
			
		||||
  before_each(clear)
 | 
			
		||||
 | 
			
		||||
  local function init_abc()
 | 
			
		||||
    execute('args a b c')
 | 
			
		||||
    execute('next')
 | 
			
		||||
    command('args a b c')
 | 
			
		||||
    command('next')
 | 
			
		||||
  end
 | 
			
		||||
 | 
			
		||||
  local function reset_arglist()
 | 
			
		||||
    execute('arga a | %argd')
 | 
			
		||||
    command('arga a | %argd')
 | 
			
		||||
  end
 | 
			
		||||
 | 
			
		||||
  local function assert_fails(cmd, err)
 | 
			
		||||
@@ -23,183 +23,183 @@ describe('argument list commands', function()
 | 
			
		||||
  end
 | 
			
		||||
 | 
			
		||||
  it('test that argidx() works', function()
 | 
			
		||||
    execute('args a b c')
 | 
			
		||||
    execute('last')
 | 
			
		||||
    command('args a b c')
 | 
			
		||||
    command('last')
 | 
			
		||||
    eq(2, eval('argidx()'))
 | 
			
		||||
    execute('%argdelete')
 | 
			
		||||
    command('%argdelete')
 | 
			
		||||
    eq(0, eval('argidx()'))
 | 
			
		||||
 | 
			
		||||
    execute('args a b c')
 | 
			
		||||
    command('args a b c')
 | 
			
		||||
    eq(0, eval('argidx()'))
 | 
			
		||||
    execute('next')
 | 
			
		||||
    command('next')
 | 
			
		||||
    eq(1, eval('argidx()'))
 | 
			
		||||
    execute('next')
 | 
			
		||||
    command('next')
 | 
			
		||||
    eq(2, eval('argidx()'))
 | 
			
		||||
    execute('1argdelete')
 | 
			
		||||
    command('1argdelete')
 | 
			
		||||
    eq(1, eval('argidx()'))
 | 
			
		||||
    execute('1argdelete')
 | 
			
		||||
    command('1argdelete')
 | 
			
		||||
    eq(0, eval('argidx()'))
 | 
			
		||||
    execute('1argdelete')
 | 
			
		||||
    command('1argdelete')
 | 
			
		||||
    eq(0, eval('argidx()'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('test that argadd() works', function()
 | 
			
		||||
    execute('%argdelete')
 | 
			
		||||
    execute('argadd a b c')
 | 
			
		||||
    command('%argdelete')
 | 
			
		||||
    command('argadd a b c')
 | 
			
		||||
    eq(0, eval('argidx()'))
 | 
			
		||||
 | 
			
		||||
    execute('%argdelete')
 | 
			
		||||
    execute('argadd a')
 | 
			
		||||
    command('%argdelete')
 | 
			
		||||
    command('argadd a')
 | 
			
		||||
    eq(0, eval('argidx()'))
 | 
			
		||||
    execute('argadd b c d')
 | 
			
		||||
    command('argadd b c d')
 | 
			
		||||
    eq(0, eval('argidx()'))
 | 
			
		||||
 | 
			
		||||
    init_abc()
 | 
			
		||||
    execute('argadd x')
 | 
			
		||||
    command('argadd x')
 | 
			
		||||
    eq({'a', 'b', 'x', 'c'}, eval('argv()'))
 | 
			
		||||
    eq(1, eval('argidx()'))
 | 
			
		||||
 | 
			
		||||
    init_abc()
 | 
			
		||||
    execute('0argadd x')
 | 
			
		||||
    command('0argadd x')
 | 
			
		||||
    eq({'x', 'a', 'b', 'c'}, eval('argv()'))
 | 
			
		||||
    eq(2, eval('argidx()'))
 | 
			
		||||
 | 
			
		||||
    init_abc()
 | 
			
		||||
    execute('1argadd x')
 | 
			
		||||
    command('1argadd x')
 | 
			
		||||
    eq({'a', 'x', 'b', 'c'}, eval('argv()'))
 | 
			
		||||
    eq(2, eval('argidx()'))
 | 
			
		||||
 | 
			
		||||
    init_abc()
 | 
			
		||||
    execute('$argadd x')
 | 
			
		||||
    command('$argadd x')
 | 
			
		||||
    eq({'a', 'b', 'c', 'x'}, eval('argv()'))
 | 
			
		||||
    eq(1, eval('argidx()'))
 | 
			
		||||
 | 
			
		||||
    init_abc()
 | 
			
		||||
    execute('$argadd x')
 | 
			
		||||
    execute('+2argadd y')
 | 
			
		||||
    command('$argadd x')
 | 
			
		||||
    command('+2argadd y')
 | 
			
		||||
    eq({'a', 'b', 'c', 'x', 'y'}, eval('argv()'))
 | 
			
		||||
    eq(1, eval('argidx()'))
 | 
			
		||||
 | 
			
		||||
    execute('%argd')
 | 
			
		||||
    execute('edit d')
 | 
			
		||||
    execute('arga')
 | 
			
		||||
    command('%argd')
 | 
			
		||||
    command('edit d')
 | 
			
		||||
    command('arga')
 | 
			
		||||
    eq(1, eval('len(argv())'))
 | 
			
		||||
    eq('d', eval('get(argv(), 0, "")'))
 | 
			
		||||
 | 
			
		||||
    execute('%argd')
 | 
			
		||||
    execute('new')
 | 
			
		||||
    execute('arga')
 | 
			
		||||
    command('%argd')
 | 
			
		||||
    command('new')
 | 
			
		||||
    command('arga')
 | 
			
		||||
    eq(0, eval('len(argv())'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('test for [count]argument and [count]argdelete commands', function()
 | 
			
		||||
    reset_arglist()
 | 
			
		||||
    execute('let save_hidden = &hidden')
 | 
			
		||||
    execute('set hidden')
 | 
			
		||||
    execute('let g:buffers = []')
 | 
			
		||||
    execute('augroup TEST')
 | 
			
		||||
    execute([[au BufEnter * call add(buffers, expand('%:t'))]])
 | 
			
		||||
    execute('augroup END')
 | 
			
		||||
    command('let save_hidden = &hidden')
 | 
			
		||||
    command('set hidden')
 | 
			
		||||
    command('let g:buffers = []')
 | 
			
		||||
    command('augroup TEST')
 | 
			
		||||
    command([[au BufEnter * call add(buffers, expand('%:t'))]])
 | 
			
		||||
    command('augroup END')
 | 
			
		||||
 | 
			
		||||
    execute('argadd a b c d')
 | 
			
		||||
    execute('$argu')
 | 
			
		||||
    execute('$-argu')
 | 
			
		||||
    execute('-argu')
 | 
			
		||||
    execute('1argu')
 | 
			
		||||
    execute('+2argu')
 | 
			
		||||
    command('argadd a b c d')
 | 
			
		||||
    command('$argu')
 | 
			
		||||
    command('$-argu')
 | 
			
		||||
    command('-argu')
 | 
			
		||||
    command('1argu')
 | 
			
		||||
    command('+2argu')
 | 
			
		||||
 | 
			
		||||
    execute('augroup TEST')
 | 
			
		||||
    execute('au!')
 | 
			
		||||
    execute('augroup END')
 | 
			
		||||
    command('augroup TEST')
 | 
			
		||||
    command('au!')
 | 
			
		||||
    command('augroup END')
 | 
			
		||||
 | 
			
		||||
    eq({'d', 'c', 'b', 'a', 'c'}, eval('g:buffers'))
 | 
			
		||||
 | 
			
		||||
    execute('redir => result')
 | 
			
		||||
    execute('ar')
 | 
			
		||||
    execute('redir END')
 | 
			
		||||
    command('redir => result')
 | 
			
		||||
    command('ar')
 | 
			
		||||
    command('redir END')
 | 
			
		||||
    eq(1, eval([[result =~# 'a b \[c] d']]))
 | 
			
		||||
 | 
			
		||||
    execute('.argd')
 | 
			
		||||
    command('.argd')
 | 
			
		||||
    eq({'a', 'b', 'd'}, eval('argv()'))
 | 
			
		||||
 | 
			
		||||
    execute('-argd')
 | 
			
		||||
    command('-argd')
 | 
			
		||||
    eq({'a', 'd'}, eval('argv()'))
 | 
			
		||||
 | 
			
		||||
    execute('$argd')
 | 
			
		||||
    command('$argd')
 | 
			
		||||
    eq({'a'}, eval('argv()'))
 | 
			
		||||
 | 
			
		||||
    execute('1arga c')
 | 
			
		||||
    execute('1arga b')
 | 
			
		||||
    execute('$argu')
 | 
			
		||||
    execute('$arga x')
 | 
			
		||||
    command('1arga c')
 | 
			
		||||
    command('1arga b')
 | 
			
		||||
    command('$argu')
 | 
			
		||||
    command('$arga x')
 | 
			
		||||
    eq({'a', 'b', 'c', 'x'}, eval('argv()'))
 | 
			
		||||
 | 
			
		||||
    execute('0arga Y')
 | 
			
		||||
    command('0arga Y')
 | 
			
		||||
    eq({'Y', 'a', 'b', 'c', 'x'}, eval('argv()'))
 | 
			
		||||
 | 
			
		||||
    execute('%argd')
 | 
			
		||||
    command('%argd')
 | 
			
		||||
    eq({}, eval('argv()'))
 | 
			
		||||
 | 
			
		||||
    execute('arga a b c d e f')
 | 
			
		||||
    execute('2,$-argd')
 | 
			
		||||
    command('arga a b c d e f')
 | 
			
		||||
    command('2,$-argd')
 | 
			
		||||
    eq({'a', 'f'}, eval('argv()'))
 | 
			
		||||
 | 
			
		||||
    execute('let &hidden = save_hidden')
 | 
			
		||||
    command('let &hidden = save_hidden')
 | 
			
		||||
 | 
			
		||||
    -- Setting the argument list should fail when the current buffer has
 | 
			
		||||
    -- unsaved changes
 | 
			
		||||
    execute('%argd')
 | 
			
		||||
    execute('enew!')
 | 
			
		||||
    execute('set modified')
 | 
			
		||||
    command('%argd')
 | 
			
		||||
    command('enew!')
 | 
			
		||||
    command('set modified')
 | 
			
		||||
    assert_fails('args x y z', 'E37:')
 | 
			
		||||
    execute('args! x y z')
 | 
			
		||||
    command('args! x y z')
 | 
			
		||||
    eq({'x', 'y', 'z'}, eval('argv()'))
 | 
			
		||||
    eq('x', eval('expand("%:t")'))
 | 
			
		||||
 | 
			
		||||
    execute('%argdelete')
 | 
			
		||||
    command('%argdelete')
 | 
			
		||||
    assert_fails('argument', 'E163:')
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('test for 0argadd and 0argedit', function()
 | 
			
		||||
    reset_arglist()
 | 
			
		||||
 | 
			
		||||
    execute('arga a b c d')
 | 
			
		||||
    execute('2argu')
 | 
			
		||||
    execute('0arga added')
 | 
			
		||||
    command('arga a b c d')
 | 
			
		||||
    command('2argu')
 | 
			
		||||
    command('0arga added')
 | 
			
		||||
    eq({'added', 'a', 'b', 'c', 'd'}, eval('argv()'))
 | 
			
		||||
 | 
			
		||||
    execute('%argd')
 | 
			
		||||
    execute('arga a b c d')
 | 
			
		||||
    execute('2argu')
 | 
			
		||||
    execute('0arge edited')
 | 
			
		||||
    command('%argd')
 | 
			
		||||
    command('arga a b c d')
 | 
			
		||||
    command('2argu')
 | 
			
		||||
    command('0arge edited')
 | 
			
		||||
    eq({'edited', 'a', 'b', 'c', 'd'}, eval('argv()'))
 | 
			
		||||
 | 
			
		||||
    execute('2argu')
 | 
			
		||||
    execute('arga third')
 | 
			
		||||
    command('2argu')
 | 
			
		||||
    command('arga third')
 | 
			
		||||
    eq({'edited', 'a', 'third', 'b', 'c', 'd'}, eval('argv()'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('test for argc()', function()
 | 
			
		||||
    reset_arglist()
 | 
			
		||||
    eq(0, eval('argc()'))
 | 
			
		||||
    execute('argadd a b')
 | 
			
		||||
    command('argadd a b')
 | 
			
		||||
    eq(2, eval('argc()'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('test for arglistid()', function()
 | 
			
		||||
    reset_arglist()
 | 
			
		||||
    execute('arga a b')
 | 
			
		||||
    command('arga a b')
 | 
			
		||||
    eq(0, eval('arglistid()'))
 | 
			
		||||
    execute('split')
 | 
			
		||||
    execute('arglocal')
 | 
			
		||||
    command('split')
 | 
			
		||||
    command('arglocal')
 | 
			
		||||
    eq(1, eval('arglistid()'))
 | 
			
		||||
    execute('tabnew | tabfirst')
 | 
			
		||||
    command('tabnew | tabfirst')
 | 
			
		||||
    eq(0, eval('arglistid(2)'))
 | 
			
		||||
    eq(1, eval('arglistid(1, 1)'))
 | 
			
		||||
    eq(0, eval('arglistid(2, 1)'))
 | 
			
		||||
    eq(1, eval('arglistid(1, 2)'))
 | 
			
		||||
    execute('tabonly | only | enew!')
 | 
			
		||||
    execute('argglobal')
 | 
			
		||||
    command('tabonly | only | enew!')
 | 
			
		||||
    command('argglobal')
 | 
			
		||||
    eq(0, eval('arglistid()'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
@@ -207,95 +207,95 @@ describe('argument list commands', function()
 | 
			
		||||
    reset_arglist()
 | 
			
		||||
    eq({}, eval('argv()'))
 | 
			
		||||
    eq('', eval('argv(2)'))
 | 
			
		||||
    execute('argadd a b c d')
 | 
			
		||||
    command('argadd a b c d')
 | 
			
		||||
    eq('c', eval('argv(2)'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('test for :argedit command', function()
 | 
			
		||||
    reset_arglist()
 | 
			
		||||
    execute('argedit a')
 | 
			
		||||
    command('argedit a')
 | 
			
		||||
    eq({'a'}, eval('argv()'))
 | 
			
		||||
    eq('a', eval('expand("%:t")'))
 | 
			
		||||
    execute('argedit b')
 | 
			
		||||
    command('argedit b')
 | 
			
		||||
    eq({'a', 'b'}, eval('argv()'))
 | 
			
		||||
    eq('b', eval('expand("%:t")'))
 | 
			
		||||
    execute('argedit a')
 | 
			
		||||
    command('argedit a')
 | 
			
		||||
    eq({'a', 'b'}, eval('argv()'))
 | 
			
		||||
    eq('a', eval('expand("%:t")'))
 | 
			
		||||
    execute('argedit c')
 | 
			
		||||
    command('argedit c')
 | 
			
		||||
    eq({'a', 'c', 'b'}, eval('argv()'))
 | 
			
		||||
    execute('0argedit x')
 | 
			
		||||
    command('0argedit x')
 | 
			
		||||
    eq({'x', 'a', 'c', 'b'}, eval('argv()'))
 | 
			
		||||
    execute('enew! | set modified')
 | 
			
		||||
    command('enew! | set modified')
 | 
			
		||||
    assert_fails('argedit y', 'E37:')
 | 
			
		||||
    execute('argedit! y')
 | 
			
		||||
    command('argedit! y')
 | 
			
		||||
    eq({'x', 'y', 'a', 'c', 'b'}, eval('argv()'))
 | 
			
		||||
    execute('%argd')
 | 
			
		||||
    command('%argd')
 | 
			
		||||
    -- Nvim allows unescaped spaces in filename on all platforms. #6010
 | 
			
		||||
    execute('argedit a b')
 | 
			
		||||
    command('argedit a b')
 | 
			
		||||
    eq({'a b'}, eval('argv()'))
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('test for :argdelete command', function()
 | 
			
		||||
    reset_arglist()
 | 
			
		||||
    execute('args aa a aaa b bb')
 | 
			
		||||
    execute('argdelete a*')
 | 
			
		||||
    command('args aa a aaa b bb')
 | 
			
		||||
    command('argdelete a*')
 | 
			
		||||
    eq({'b', 'bb'}, eval('argv()'))
 | 
			
		||||
    eq('aa', eval('expand("%:t")'))
 | 
			
		||||
    execute('last')
 | 
			
		||||
    execute('argdelete %')
 | 
			
		||||
    command('last')
 | 
			
		||||
    command('argdelete %')
 | 
			
		||||
    eq({'b'}, eval('argv()'))
 | 
			
		||||
    assert_fails('argdelete', 'E471:')
 | 
			
		||||
    assert_fails('1,100argdelete', 'E16:')
 | 
			
		||||
    execute('%argd')
 | 
			
		||||
    command('%argd')
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
  it('test for the :next, :prev, :first, :last, :rewind commands', function()
 | 
			
		||||
    reset_arglist()
 | 
			
		||||
    execute('args a b c d')
 | 
			
		||||
    execute('last')
 | 
			
		||||
    command('args a b c d')
 | 
			
		||||
    command('last')
 | 
			
		||||
    eq(3, eval('argidx()'))
 | 
			
		||||
    assert_fails('next', 'E165:')
 | 
			
		||||
    execute('prev')
 | 
			
		||||
    command('prev')
 | 
			
		||||
    eq(2, eval('argidx()'))
 | 
			
		||||
    execute('Next')
 | 
			
		||||
    command('Next')
 | 
			
		||||
    eq(1, eval('argidx()'))
 | 
			
		||||
    execute('first')
 | 
			
		||||
    command('first')
 | 
			
		||||
    eq(0, eval('argidx()'))
 | 
			
		||||
    assert_fails('prev', 'E164:')
 | 
			
		||||
    execute('3next')
 | 
			
		||||
    command('3next')
 | 
			
		||||
    eq(3, eval('argidx()'))
 | 
			
		||||
    execute('rewind')
 | 
			
		||||
    command('rewind')
 | 
			
		||||
    eq(0, eval('argidx()'))
 | 
			
		||||
    execute('%argd')
 | 
			
		||||
    command('%argd')
 | 
			
		||||
  end)
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
  it('test for autocommand that redefines the argument list, when doing ":all"', function()
 | 
			
		||||
    execute('autocmd BufReadPost Xxx2 next Xxx2 Xxx1')
 | 
			
		||||
    execute("call writefile(['test file Xxx1'], 'Xxx1')")
 | 
			
		||||
    execute("call writefile(['test file Xxx2'], 'Xxx2')")
 | 
			
		||||
    execute("call writefile(['test file Xxx3'], 'Xxx3')")
 | 
			
		||||
    command('autocmd BufReadPost Xxx2 next Xxx2 Xxx1')
 | 
			
		||||
    command("call writefile(['test file Xxx1'], 'Xxx1')")
 | 
			
		||||
    command("call writefile(['test file Xxx2'], 'Xxx2')")
 | 
			
		||||
    command("call writefile(['test file Xxx3'], 'Xxx3')")
 | 
			
		||||
 | 
			
		||||
    execute('new')
 | 
			
		||||
    command('new')
 | 
			
		||||
    -- redefine arglist; go to Xxx1
 | 
			
		||||
    execute('next! Xxx1 Xxx2 Xxx3')
 | 
			
		||||
    command('next! Xxx1 Xxx2 Xxx3')
 | 
			
		||||
    -- open window for all args
 | 
			
		||||
    execute('all')
 | 
			
		||||
    command('all')
 | 
			
		||||
    eq('test file Xxx1', eval('getline(1)'))
 | 
			
		||||
    execute('wincmd w')
 | 
			
		||||
    execute('wincmd w')
 | 
			
		||||
    command('wincmd w')
 | 
			
		||||
    command('wincmd w')
 | 
			
		||||
    eq('test file Xxx1', eval('getline(1)'))
 | 
			
		||||
    -- should now be in Xxx2
 | 
			
		||||
    execute('rewind')
 | 
			
		||||
    command('rewind')
 | 
			
		||||
    eq('test file Xxx2', eval('getline(1)'))
 | 
			
		||||
 | 
			
		||||
    execute('autocmd! BufReadPost Xxx2')
 | 
			
		||||
    execute('enew! | only')
 | 
			
		||||
    execute("call delete('Xxx1')")
 | 
			
		||||
    execute("call delete('Xxx2')")
 | 
			
		||||
    execute("call delete('Xxx3')")
 | 
			
		||||
    execute('argdelete Xxx*')
 | 
			
		||||
    execute('bwipe! Xxx1 Xxx2 Xxx3')
 | 
			
		||||
    command('autocmd! BufReadPost Xxx2')
 | 
			
		||||
    command('enew! | only')
 | 
			
		||||
    command("call delete('Xxx1')")
 | 
			
		||||
    command("call delete('Xxx2')")
 | 
			
		||||
    command("call delete('Xxx3')")
 | 
			
		||||
    command('argdelete Xxx*')
 | 
			
		||||
    command('bwipe! Xxx1 Xxx2 Xxx3')
 | 
			
		||||
  end)
 | 
			
		||||
end)
 | 
			
		||||
 
 | 
			
		||||
@@ -1,7 +1,7 @@
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local nvim, call = helpers.meths, helpers.call
 | 
			
		||||
local clear, eq = helpers.clear, helpers.eq
 | 
			
		||||
local source, execute = helpers.source, helpers.execute
 | 
			
		||||
local source, command = helpers.source, helpers.command
 | 
			
		||||
local exc_exec = helpers.exc_exec
 | 
			
		||||
 | 
			
		||||
local function expected_errors(errors)
 | 
			
		||||
@@ -55,7 +55,7 @@ describe('assert function:', function()
 | 
			
		||||
 | 
			
		||||
    it('should change v:errors when expected is not equal to actual', function()
 | 
			
		||||
      -- Lua does not tell integer from float.
 | 
			
		||||
      execute('call assert_equal(1, 1.0)')
 | 
			
		||||
      command('call assert_equal(1, 1.0)')
 | 
			
		||||
      expected_errors({'Expected 1 but got 1.0'})
 | 
			
		||||
    end)
 | 
			
		||||
 | 
			
		||||
@@ -219,8 +219,8 @@ describe('assert function:', function()
 | 
			
		||||
  -- assert_fails({cmd}, [, {error}])
 | 
			
		||||
  describe('assert_fails', function()
 | 
			
		||||
    it('should change v:errors when error does not match v:errmsg', function()
 | 
			
		||||
      execute([[call assert_fails('xxx', {})]])
 | 
			
		||||
      execute([[call assert_match("Expected {} but got 'E731:", v:errors[0])]])
 | 
			
		||||
      command([[call assert_fails('xxx', {})]])
 | 
			
		||||
      command([[call assert_match("Expected {} but got 'E731:", v:errors[0])]])
 | 
			
		||||
      expected_errors({"Expected {} but got 'E731: using Dictionary as a String'"})
 | 
			
		||||
    end)
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
@@ -1,7 +1,7 @@
 | 
			
		||||
local lfs = require('lfs')
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear, eq = helpers.clear, helpers.eq
 | 
			
		||||
local eval, execute = helpers.eval, helpers.execute
 | 
			
		||||
local eval, command = helpers.eval, helpers.command
 | 
			
		||||
 | 
			
		||||
describe('autochdir behavior', function()
 | 
			
		||||
  local dir = 'Xtest-functional-legacy-autochdir'
 | 
			
		||||
@@ -17,9 +17,9 @@ describe('autochdir behavior', function()
 | 
			
		||||
 | 
			
		||||
  -- Tests vim/vim/777 without test_autochdir().
 | 
			
		||||
  it('sets filename', function()
 | 
			
		||||
    execute('set acd')
 | 
			
		||||
    execute('new')
 | 
			
		||||
    execute('w '..dir..'/Xtest')
 | 
			
		||||
    command('set acd')
 | 
			
		||||
    command('new')
 | 
			
		||||
    command('w '..dir..'/Xtest')
 | 
			
		||||
    eq('Xtest', eval("expand('%')"))
 | 
			
		||||
    eq(dir, eval([[substitute(getcwd(), '.*[/\\]\(\k*\)', '\1', '')]]))
 | 
			
		||||
  end)
 | 
			
		||||
 
 | 
			
		||||
@@ -4,7 +4,7 @@ local clear, eq, neq = helpers.clear, helpers.eq, helpers.neq
 | 
			
		||||
local curbuf, buf = helpers.curbuf, helpers.bufmeths
 | 
			
		||||
local curwin = helpers.curwin
 | 
			
		||||
local redir_exec = helpers.redir_exec
 | 
			
		||||
local source, execute = helpers.source, helpers.execute
 | 
			
		||||
local source, command = helpers.source, helpers.command
 | 
			
		||||
 | 
			
		||||
local function declare_hook_function()
 | 
			
		||||
  source([[
 | 
			
		||||
@@ -25,7 +25,7 @@ local function declare_hook_function()
 | 
			
		||||
end
 | 
			
		||||
 | 
			
		||||
local function set_hook(pattern)
 | 
			
		||||
  execute(
 | 
			
		||||
  command(
 | 
			
		||||
    'au OptionSet '
 | 
			
		||||
    .. pattern ..
 | 
			
		||||
    ' :call AutoCommand(expand("<amatch>"), bufnr("%"), winnr())'
 | 
			
		||||
@@ -33,7 +33,7 @@ local function set_hook(pattern)
 | 
			
		||||
end
 | 
			
		||||
 | 
			
		||||
local function init_var()
 | 
			
		||||
  execute('let g:ret = []')
 | 
			
		||||
  command('let g:ret = []')
 | 
			
		||||
end
 | 
			
		||||
 | 
			
		||||
local function get_result()
 | 
			
		||||
@@ -88,9 +88,9 @@ end
 | 
			
		||||
 | 
			
		||||
local function make_buffer()
 | 
			
		||||
  local old_buf = curbuf()
 | 
			
		||||
  execute('botright new')
 | 
			
		||||
  command('botright new')
 | 
			
		||||
  local new_buf = curbuf()
 | 
			
		||||
  execute('wincmd p') -- move previous window
 | 
			
		||||
  command('wincmd p') -- move previous window
 | 
			
		||||
 | 
			
		||||
  neq(old_buf, new_buf)
 | 
			
		||||
  eq(old_buf, curbuf())
 | 
			
		||||
@@ -100,10 +100,10 @@ end
 | 
			
		||||
 | 
			
		||||
local function get_new_window_number()
 | 
			
		||||
  local old_win = curwin()
 | 
			
		||||
  execute('botright new')
 | 
			
		||||
  command('botright new')
 | 
			
		||||
  local new_win = curwin()
 | 
			
		||||
  local new_winnr = redir_exec('echo winnr()')
 | 
			
		||||
  execute('wincmd p') -- move previous window
 | 
			
		||||
  command('wincmd p') -- move previous window
 | 
			
		||||
 | 
			
		||||
  neq(old_win, new_win)
 | 
			
		||||
  eq(old_win, curwin())
 | 
			
		||||
@@ -122,42 +122,42 @@ describe('au OptionSet', function()
 | 
			
		||||
    end)
 | 
			
		||||
 | 
			
		||||
    it('should be called in setting number option', function()
 | 
			
		||||
      execute('set nu')
 | 
			
		||||
      command('set nu')
 | 
			
		||||
      expected_combination({'number', 0, 1, 'global'})
 | 
			
		||||
 | 
			
		||||
      execute('setlocal nonu')
 | 
			
		||||
      command('setlocal nonu')
 | 
			
		||||
      expected_combination({'number', 1, 0, 'local'})
 | 
			
		||||
 | 
			
		||||
      execute('setglobal nonu')
 | 
			
		||||
      command('setglobal nonu')
 | 
			
		||||
      expected_combination({'number', 1, 0, 'global'})
 | 
			
		||||
    end)
 | 
			
		||||
 | 
			
		||||
    it('should be called in setting autoindent option',function()
 | 
			
		||||
      execute('setlocal ai')
 | 
			
		||||
      command('setlocal ai')
 | 
			
		||||
      expected_combination({'autoindent', 0, 1, 'local'})
 | 
			
		||||
 | 
			
		||||
      execute('setglobal ai')
 | 
			
		||||
      command('setglobal ai')
 | 
			
		||||
      expected_combination({'autoindent', 0, 1, 'global'})
 | 
			
		||||
 | 
			
		||||
      execute('set noai')
 | 
			
		||||
      command('set noai')
 | 
			
		||||
      expected_combination({'autoindent', 1, 0, 'global'})
 | 
			
		||||
    end)
 | 
			
		||||
 | 
			
		||||
    it('should be called in inverting global autoindent option',function()
 | 
			
		||||
      execute('set ai!')
 | 
			
		||||
      command('set ai!')
 | 
			
		||||
      expected_combination({'autoindent', 0, 1, 'global'})
 | 
			
		||||
    end)
 | 
			
		||||
 | 
			
		||||
    it('should be called in being unset local autoindent option',function()
 | 
			
		||||
      execute('setlocal ai')
 | 
			
		||||
      command('setlocal ai')
 | 
			
		||||
      expected_combination({'autoindent', 0, 1, 'local'})
 | 
			
		||||
 | 
			
		||||
      execute('setlocal ai<')
 | 
			
		||||
      command('setlocal ai<')
 | 
			
		||||
      expected_combination({'autoindent', 1, 0, 'local'})
 | 
			
		||||
    end)
 | 
			
		||||
 | 
			
		||||
    it('should be called in setting global list and number option at the same time',function()
 | 
			
		||||
      execute('set list nu')
 | 
			
		||||
      command('set list nu')
 | 
			
		||||
      expected_combination(
 | 
			
		||||
        {'list', 0, 1, 'global'},
 | 
			
		||||
        {'number', 0, 1, 'global'}
 | 
			
		||||
@@ -165,41 +165,41 @@ describe('au OptionSet', function()
 | 
			
		||||
    end)
 | 
			
		||||
 | 
			
		||||
    it('should not print anything, use :noa', function()
 | 
			
		||||
      execute('noa set nolist nonu')
 | 
			
		||||
      command('noa set nolist nonu')
 | 
			
		||||
      expected_empty()
 | 
			
		||||
    end)
 | 
			
		||||
 | 
			
		||||
    it('should be called in setting local acd', function()
 | 
			
		||||
      execute('setlocal acd')
 | 
			
		||||
      command('setlocal acd')
 | 
			
		||||
      expected_combination({'autochdir', 0, 1, 'local'})
 | 
			
		||||
    end)
 | 
			
		||||
 | 
			
		||||
    it('should be called in setting autoread', function()
 | 
			
		||||
      execute('set noar')
 | 
			
		||||
      command('set noar')
 | 
			
		||||
      expected_combination({'autoread', 1, 0, 'global'})
 | 
			
		||||
 | 
			
		||||
      execute('setlocal ar')
 | 
			
		||||
      command('setlocal ar')
 | 
			
		||||
      expected_combination({'autoread', 0, 1, 'local'})
 | 
			
		||||
    end)
 | 
			
		||||
 | 
			
		||||
    it('should be called in inverting global autoread', function()
 | 
			
		||||
      execute('setglobal invar')
 | 
			
		||||
      command('setglobal invar')
 | 
			
		||||
      expected_combination({'autoread', 1, 0, 'global'})
 | 
			
		||||
    end)
 | 
			
		||||
 | 
			
		||||
    it('should be called in setting backspace option through :let', function()
 | 
			
		||||
      execute('let &bs=""')
 | 
			
		||||
      command('let &bs=""')
 | 
			
		||||
      expected_combination({'backspace', 'indent,eol,start', '', 'global'})
 | 
			
		||||
    end)
 | 
			
		||||
 | 
			
		||||
    describe('being set by setbufvar()', function()
 | 
			
		||||
      it('should not trigger because option name is invalid', function()
 | 
			
		||||
        execute('call setbufvar(1, "&l:bk", 1)')
 | 
			
		||||
        command('call setbufvar(1, "&l:bk", 1)')
 | 
			
		||||
        expected_empty()
 | 
			
		||||
      end)
 | 
			
		||||
 | 
			
		||||
      it('should trigger using correct option name', function()
 | 
			
		||||
        execute('call setbufvar(1, "&backup", 1)')
 | 
			
		||||
        command('call setbufvar(1, "&backup", 1)')
 | 
			
		||||
        expected_combination({'backup', 0, 1, 'local'})
 | 
			
		||||
      end)
 | 
			
		||||
 | 
			
		||||
@@ -207,7 +207,7 @@ describe('au OptionSet', function()
 | 
			
		||||
        local new_buffer = make_buffer()
 | 
			
		||||
        local new_bufnr = buf.get_number(new_buffer)
 | 
			
		||||
 | 
			
		||||
        execute('call setbufvar(' .. new_bufnr .. ', "&buftype", "nofile")')
 | 
			
		||||
        command('call setbufvar(' .. new_bufnr .. ', "&buftype", "nofile")')
 | 
			
		||||
        expected_combination({'buftype', '', 'nofile', 'local', {bufnr = new_bufnr}})
 | 
			
		||||
      end)
 | 
			
		||||
    end)
 | 
			
		||||
@@ -224,16 +224,16 @@ describe('au OptionSet', function()
 | 
			
		||||
    it('should be called iff setting readonly', function()
 | 
			
		||||
      set_hook('readonly')
 | 
			
		||||
 | 
			
		||||
      execute('set nu')
 | 
			
		||||
      command('set nu')
 | 
			
		||||
      expected_empty()
 | 
			
		||||
 | 
			
		||||
      execute('setlocal ro')
 | 
			
		||||
      command('setlocal ro')
 | 
			
		||||
      expected_combination({'readonly', 0, 1, 'local'})
 | 
			
		||||
 | 
			
		||||
      execute('setglobal ro')
 | 
			
		||||
      command('setglobal ro')
 | 
			
		||||
      expected_combination({'readonly', 0, 1, 'global'})
 | 
			
		||||
 | 
			
		||||
      execute('set noro')
 | 
			
		||||
      command('set noro')
 | 
			
		||||
      expected_combination({'readonly', 1, 0, 'global'})
 | 
			
		||||
    end)
 | 
			
		||||
 | 
			
		||||
@@ -241,14 +241,14 @@ describe('au OptionSet', function()
 | 
			
		||||
      it('should not trigger because option name does not match with backup', function()
 | 
			
		||||
        set_hook('backup')
 | 
			
		||||
 | 
			
		||||
        execute('call setbufvar(1, "&l:bk", 1)')
 | 
			
		||||
        command('call setbufvar(1, "&l:bk", 1)')
 | 
			
		||||
        expected_empty()
 | 
			
		||||
      end)
 | 
			
		||||
 | 
			
		||||
      it('should trigger, use correct option name backup', function()
 | 
			
		||||
        set_hook('backup')
 | 
			
		||||
 | 
			
		||||
        execute('call setbufvar(1, "&backup", 1)')
 | 
			
		||||
        command('call setbufvar(1, "&backup", 1)')
 | 
			
		||||
        expected_combination({'backup', 0, 1, 'local'})
 | 
			
		||||
      end)
 | 
			
		||||
 | 
			
		||||
@@ -258,7 +258,7 @@ describe('au OptionSet', function()
 | 
			
		||||
        local new_buffer = make_buffer()
 | 
			
		||||
        local new_bufnr = buf.get_number(new_buffer)
 | 
			
		||||
 | 
			
		||||
        execute('call setbufvar(' .. new_bufnr .. ', "&buftype", "nofile")')
 | 
			
		||||
        command('call setbufvar(' .. new_bufnr .. ', "&buftype", "nofile")')
 | 
			
		||||
        expected_combination({'buftype', '', 'nofile', 'local', {bufnr = new_bufnr}})
 | 
			
		||||
      end)
 | 
			
		||||
    end)
 | 
			
		||||
@@ -267,14 +267,14 @@ describe('au OptionSet', function()
 | 
			
		||||
      it('should not trigger because option name does not match with backup', function()
 | 
			
		||||
        set_hook('backup')
 | 
			
		||||
 | 
			
		||||
        execute('call setwinvar(1, "&l:bk", 1)')
 | 
			
		||||
        command('call setwinvar(1, "&l:bk", 1)')
 | 
			
		||||
        expected_empty()
 | 
			
		||||
      end)
 | 
			
		||||
 | 
			
		||||
      it('should trigger, use correct option name backup', function()
 | 
			
		||||
        set_hook('backup')
 | 
			
		||||
 | 
			
		||||
        execute('call setwinvar(1, "&backup", 1)')
 | 
			
		||||
        command('call setwinvar(1, "&backup", 1)')
 | 
			
		||||
        expected_combination({'backup', 0, 1, 'local'})
 | 
			
		||||
      end)
 | 
			
		||||
 | 
			
		||||
@@ -283,7 +283,7 @@ describe('au OptionSet', function()
 | 
			
		||||
 | 
			
		||||
        local new_winnr = get_new_window_number()
 | 
			
		||||
 | 
			
		||||
        execute('call setwinvar(' .. new_winnr .. ', "&cursorcolumn", 1)')
 | 
			
		||||
        command('call setwinvar(' .. new_winnr .. ', "&cursorcolumn", 1)')
 | 
			
		||||
        -- expected_combination({'cursorcolumn', 0, 1, 'local', {winnr = new_winnr}})
 | 
			
		||||
        expected_empty()
 | 
			
		||||
      end)
 | 
			
		||||
 
 | 
			
		||||
@@ -1,9 +1,9 @@
 | 
			
		||||
-- vim: set foldmethod=marker foldmarker=[[,]] :
 | 
			
		||||
-- Tests for setting the '[,'] marks when joining lines.
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear, feed, insert = helpers.clear, helpers.feed, helpers.insert
 | 
			
		||||
local execute, expect = helpers.execute, helpers.expect
 | 
			
		||||
local command, expect = helpers.command, helpers.expect
 | 
			
		||||
local wait = helpers.wait
 | 
			
		||||
 | 
			
		||||
describe('autoformat join', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
@@ -21,12 +21,13 @@ Results:]])
 | 
			
		||||
 | 
			
		||||
    feed('gg')
 | 
			
		||||
    feed('0gqj<cr>')
 | 
			
		||||
    wait()
 | 
			
		||||
 | 
			
		||||
    execute([[let a=string(getpos("'[")).'/'.string(getpos("']"))]])
 | 
			
		||||
    execute("g/^This line/;'}-join")
 | 
			
		||||
    execute([[let b=string(getpos("'[")).'/'.string(getpos("']"))]])
 | 
			
		||||
    execute("$put ='First test: Start/End '.string(a)")
 | 
			
		||||
    execute("$put ='Second test: Start/End '.string(b)")
 | 
			
		||||
    command([[let a=string(getpos("'[")).'/'.string(getpos("']"))]])
 | 
			
		||||
    command("g/^This line/;'}-join")
 | 
			
		||||
    command([[let b=string(getpos("'[")).'/'.string(getpos("']"))]])
 | 
			
		||||
    command("$put ='First test: Start/End '.string(a)")
 | 
			
		||||
    command("$put ='Second test: Start/End '.string(b)")
 | 
			
		||||
 | 
			
		||||
    expect([[
 | 
			
		||||
		O sodales, ludite, vos qui attamen consulite per voster honur.
 | 
			
		||||
 
 | 
			
		||||
@@ -2,7 +2,7 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local feed, insert = helpers.feed, helpers.insert
 | 
			
		||||
local clear, execute, expect = helpers.clear, helpers.execute, helpers.expect
 | 
			
		||||
local clear, feed_command, expect = helpers.clear, helpers.feed_command, helpers.expect
 | 
			
		||||
 | 
			
		||||
describe('breakindent', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
@@ -10,126 +10,126 @@ describe('breakindent', function()
 | 
			
		||||
  it('is working', function()
 | 
			
		||||
    insert('dummy text')
 | 
			
		||||
 | 
			
		||||
    execute('set wildchar=^E')
 | 
			
		||||
    execute('10new')
 | 
			
		||||
    execute('vsp')
 | 
			
		||||
    execute('vert resize 20')
 | 
			
		||||
    execute([[put =\"\tabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOP\"]])
 | 
			
		||||
    execute('set ts=4 sw=4 sts=4 breakindent')
 | 
			
		||||
    execute('fu! ScreenChar(line, width)')
 | 
			
		||||
    execute('	let c=""')
 | 
			
		||||
    execute('	for i in range(1,a:width)')
 | 
			
		||||
    execute('		let c.=nr2char(screenchar(a:line, i))')
 | 
			
		||||
    execute('	endfor')
 | 
			
		||||
    execute([[       let c.="\n"]])
 | 
			
		||||
    execute('	for i in range(1,a:width)')
 | 
			
		||||
    execute('		let c.=nr2char(screenchar(a:line+1, i))')
 | 
			
		||||
    execute('	endfor')
 | 
			
		||||
    execute([[       let c.="\n"]])
 | 
			
		||||
    execute('	for i in range(1,a:width)')
 | 
			
		||||
    execute('		let c.=nr2char(screenchar(a:line+2, i))')
 | 
			
		||||
    execute('	endfor')
 | 
			
		||||
    execute('	return c')
 | 
			
		||||
    execute('endfu')
 | 
			
		||||
    execute('fu DoRecordScreen()')
 | 
			
		||||
    execute('	wincmd l')
 | 
			
		||||
    execute([[	$put =printf(\"\n%s\", g:test)]])
 | 
			
		||||
    execute('	$put =g:line1')
 | 
			
		||||
    execute('	wincmd p')
 | 
			
		||||
    execute('endfu')
 | 
			
		||||
    execute('set briopt=min:0')
 | 
			
		||||
    execute('let g:test="Test 1: Simple breakindent"')
 | 
			
		||||
    execute('let line1=ScreenChar(line("."),8)')
 | 
			
		||||
    execute('call DoRecordScreen()')
 | 
			
		||||
    execute('let g:test="Test 2: Simple breakindent + sbr=>>"')
 | 
			
		||||
    execute('set sbr=>>')
 | 
			
		||||
    execute('let line1=ScreenChar(line("."),8)')
 | 
			
		||||
    execute('call DoRecordScreen()')
 | 
			
		||||
    execute('let g:test ="Test 3: Simple breakindent + briopt:sbr"')
 | 
			
		||||
    execute('set briopt=sbr,min:0 sbr=++')
 | 
			
		||||
    execute('let line1=ScreenChar(line("."),8)')
 | 
			
		||||
    execute('call DoRecordScreen()')
 | 
			
		||||
    execute('let g:test ="Test 4: Simple breakindent + min width: 18"')
 | 
			
		||||
    execute('set sbr= briopt=min:18')
 | 
			
		||||
    execute('let line1=ScreenChar(line("."),8)')
 | 
			
		||||
    execute('call DoRecordScreen()')
 | 
			
		||||
    execute('let g:test =" Test 5: Simple breakindent + shift by 2"')
 | 
			
		||||
    execute('set briopt=shift:2,min:0')
 | 
			
		||||
    execute('let line1=ScreenChar(line("."),8)')
 | 
			
		||||
    execute('call DoRecordScreen()')
 | 
			
		||||
    execute('let g:test=" Test 6: Simple breakindent + shift by -1"')
 | 
			
		||||
    execute('set briopt=shift:-1,min:0')
 | 
			
		||||
    execute('let line1=ScreenChar(line("."),8)')
 | 
			
		||||
    execute('call DoRecordScreen()')
 | 
			
		||||
    execute('let g:test=" Test 7: breakindent + shift by +1 + nu + sbr=? briopt:sbr"')
 | 
			
		||||
    execute('set briopt=shift:1,sbr,min:0 nu sbr=? nuw=4')
 | 
			
		||||
    execute('let line1=ScreenChar(line("."),10)')
 | 
			
		||||
    execute('call DoRecordScreen()')
 | 
			
		||||
    execute('let g:test=" Test 8: breakindent + shift:1 + nu + sbr=# list briopt:sbr"')
 | 
			
		||||
    execute('set briopt=shift:1,sbr,min:0 nu sbr=# list lcs&vi')
 | 
			
		||||
    execute('let line1=ScreenChar(line("."),10)')
 | 
			
		||||
    execute('call DoRecordScreen()')
 | 
			
		||||
    execute([[let g:test=" Test 9: breakindent + shift by +1 + 'nu' + sbr=# list"]])
 | 
			
		||||
    execute('set briopt-=sbr')
 | 
			
		||||
    execute('let line1=ScreenChar(line("."),10)')
 | 
			
		||||
    execute('call DoRecordScreen()')
 | 
			
		||||
    execute([[let g:test=" Test 10: breakindent + shift by +1 + 'nu' + sbr=~ cpo+=n"]])
 | 
			
		||||
    execute('set cpo+=n sbr=~ nu nuw=4 nolist briopt=sbr,min:0')
 | 
			
		||||
    execute('let line1=ScreenChar(line("."),10)')
 | 
			
		||||
    execute('call DoRecordScreen()')
 | 
			
		||||
    execute('wincmd p')
 | 
			
		||||
    execute([[let g:test="\n Test 11: strdisplaywidth when breakindent is on"]])
 | 
			
		||||
    execute('set cpo-=n sbr=>> nu nuw=4 nolist briopt= ts=4')
 | 
			
		||||
    feed_command('set wildchar=^E')
 | 
			
		||||
    feed_command('10new')
 | 
			
		||||
    feed_command('vsp')
 | 
			
		||||
    feed_command('vert resize 20')
 | 
			
		||||
    feed_command([[put =\"\tabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOP\"]])
 | 
			
		||||
    feed_command('set ts=4 sw=4 sts=4 breakindent')
 | 
			
		||||
    feed_command('fu! ScreenChar(line, width)')
 | 
			
		||||
    feed_command('	let c=""')
 | 
			
		||||
    feed_command('	for i in range(1,a:width)')
 | 
			
		||||
    feed_command('		let c.=nr2char(screenchar(a:line, i))')
 | 
			
		||||
    feed_command('	endfor')
 | 
			
		||||
    feed_command([[       let c.="\n"]])
 | 
			
		||||
    feed_command('	for i in range(1,a:width)')
 | 
			
		||||
    feed_command('		let c.=nr2char(screenchar(a:line+1, i))')
 | 
			
		||||
    feed_command('	endfor')
 | 
			
		||||
    feed_command([[       let c.="\n"]])
 | 
			
		||||
    feed_command('	for i in range(1,a:width)')
 | 
			
		||||
    feed_command('		let c.=nr2char(screenchar(a:line+2, i))')
 | 
			
		||||
    feed_command('	endfor')
 | 
			
		||||
    feed_command('	return c')
 | 
			
		||||
    feed_command('endfu')
 | 
			
		||||
    feed_command('fu DoRecordScreen()')
 | 
			
		||||
    feed_command('	wincmd l')
 | 
			
		||||
    feed_command([[	$put =printf(\"\n%s\", g:test)]])
 | 
			
		||||
    feed_command('	$put =g:line1')
 | 
			
		||||
    feed_command('	wincmd p')
 | 
			
		||||
    feed_command('endfu')
 | 
			
		||||
    feed_command('set briopt=min:0')
 | 
			
		||||
    feed_command('let g:test="Test 1: Simple breakindent"')
 | 
			
		||||
    feed_command('let line1=ScreenChar(line("."),8)')
 | 
			
		||||
    feed_command('call DoRecordScreen()')
 | 
			
		||||
    feed_command('let g:test="Test 2: Simple breakindent + sbr=>>"')
 | 
			
		||||
    feed_command('set sbr=>>')
 | 
			
		||||
    feed_command('let line1=ScreenChar(line("."),8)')
 | 
			
		||||
    feed_command('call DoRecordScreen()')
 | 
			
		||||
    feed_command('let g:test ="Test 3: Simple breakindent + briopt:sbr"')
 | 
			
		||||
    feed_command('set briopt=sbr,min:0 sbr=++')
 | 
			
		||||
    feed_command('let line1=ScreenChar(line("."),8)')
 | 
			
		||||
    feed_command('call DoRecordScreen()')
 | 
			
		||||
    feed_command('let g:test ="Test 4: Simple breakindent + min width: 18"')
 | 
			
		||||
    feed_command('set sbr= briopt=min:18')
 | 
			
		||||
    feed_command('let line1=ScreenChar(line("."),8)')
 | 
			
		||||
    feed_command('call DoRecordScreen()')
 | 
			
		||||
    feed_command('let g:test =" Test 5: Simple breakindent + shift by 2"')
 | 
			
		||||
    feed_command('set briopt=shift:2,min:0')
 | 
			
		||||
    feed_command('let line1=ScreenChar(line("."),8)')
 | 
			
		||||
    feed_command('call DoRecordScreen()')
 | 
			
		||||
    feed_command('let g:test=" Test 6: Simple breakindent + shift by -1"')
 | 
			
		||||
    feed_command('set briopt=shift:-1,min:0')
 | 
			
		||||
    feed_command('let line1=ScreenChar(line("."),8)')
 | 
			
		||||
    feed_command('call DoRecordScreen()')
 | 
			
		||||
    feed_command('let g:test=" Test 7: breakindent + shift by +1 + nu + sbr=? briopt:sbr"')
 | 
			
		||||
    feed_command('set briopt=shift:1,sbr,min:0 nu sbr=? nuw=4')
 | 
			
		||||
    feed_command('let line1=ScreenChar(line("."),10)')
 | 
			
		||||
    feed_command('call DoRecordScreen()')
 | 
			
		||||
    feed_command('let g:test=" Test 8: breakindent + shift:1 + nu + sbr=# list briopt:sbr"')
 | 
			
		||||
    feed_command('set briopt=shift:1,sbr,min:0 nu sbr=# list lcs&vi')
 | 
			
		||||
    feed_command('let line1=ScreenChar(line("."),10)')
 | 
			
		||||
    feed_command('call DoRecordScreen()')
 | 
			
		||||
    feed_command([[let g:test=" Test 9: breakindent + shift by +1 + 'nu' + sbr=# list"]])
 | 
			
		||||
    feed_command('set briopt-=sbr')
 | 
			
		||||
    feed_command('let line1=ScreenChar(line("."),10)')
 | 
			
		||||
    feed_command('call DoRecordScreen()')
 | 
			
		||||
    feed_command([[let g:test=" Test 10: breakindent + shift by +1 + 'nu' + sbr=~ cpo+=n"]])
 | 
			
		||||
    feed_command('set cpo+=n sbr=~ nu nuw=4 nolist briopt=sbr,min:0')
 | 
			
		||||
    feed_command('let line1=ScreenChar(line("."),10)')
 | 
			
		||||
    feed_command('call DoRecordScreen()')
 | 
			
		||||
    feed_command('wincmd p')
 | 
			
		||||
    feed_command([[let g:test="\n Test 11: strdisplaywidth when breakindent is on"]])
 | 
			
		||||
    feed_command('set cpo-=n sbr=>> nu nuw=4 nolist briopt= ts=4')
 | 
			
		||||
    -- Skip leading tab when calculating text width.
 | 
			
		||||
    execute('let text=getline(2)')
 | 
			
		||||
    feed_command('let text=getline(2)')
 | 
			
		||||
    -- Text wraps 3 times.
 | 
			
		||||
    execute('let width = strlen(text[1:])+indent(2)*4+strlen(&sbr)*3')
 | 
			
		||||
    execute('$put =g:test')
 | 
			
		||||
    execute([[$put =printf(\"strdisplaywidth: %d == calculated: %d\", strdisplaywidth(text), width)]])
 | 
			
		||||
    execute([[let g:str="\t\t\t\t\t{"]])
 | 
			
		||||
    execute('let g:test=" Test 12: breakindent + long indent"')
 | 
			
		||||
    execute('wincmd p')
 | 
			
		||||
    execute('set all& breakindent linebreak briopt=min:10 nu numberwidth=3 ts=4')
 | 
			
		||||
    execute('$put =g:str')
 | 
			
		||||
    feed_command('let width = strlen(text[1:])+indent(2)*4+strlen(&sbr)*3')
 | 
			
		||||
    feed_command('$put =g:test')
 | 
			
		||||
    feed_command([[$put =printf(\"strdisplaywidth: %d == calculated: %d\", strdisplaywidth(text), width)]])
 | 
			
		||||
    feed_command([[let g:str="\t\t\t\t\t{"]])
 | 
			
		||||
    feed_command('let g:test=" Test 12: breakindent + long indent"')
 | 
			
		||||
    feed_command('wincmd p')
 | 
			
		||||
    feed_command('set all& breakindent linebreak briopt=min:10 nu numberwidth=3 ts=4')
 | 
			
		||||
    feed_command('$put =g:str')
 | 
			
		||||
    feed('zt')
 | 
			
		||||
    execute('let line1=ScreenChar(1,10)')
 | 
			
		||||
    execute('wincmd p')
 | 
			
		||||
    execute('call DoRecordScreen()')
 | 
			
		||||
    feed_command('let line1=ScreenChar(1,10)')
 | 
			
		||||
    feed_command('wincmd p')
 | 
			
		||||
    feed_command('call DoRecordScreen()')
 | 
			
		||||
 | 
			
		||||
    -- Test, that the string "    a\tb\tc\td\te" is correctly displayed in a
 | 
			
		||||
    -- 20 column wide window (see bug report
 | 
			
		||||
    -- https://groups.google.com/d/msg/vim_dev/ZOdg2mc9c9Y/TT8EhFjEy0IJ ).
 | 
			
		||||
    execute('only')
 | 
			
		||||
    execute('vert 20new')
 | 
			
		||||
    execute('set all& breakindent briopt=min:10')
 | 
			
		||||
    execute([[call setline(1, ["    a\tb\tc\td\te", "    z   y       x       w       v"])]])
 | 
			
		||||
    execute([[/^\s*a]])
 | 
			
		||||
    feed_command('only')
 | 
			
		||||
    feed_command('vert 20new')
 | 
			
		||||
    feed_command('set all& breakindent briopt=min:10')
 | 
			
		||||
    feed_command([[call setline(1, ["    a\tb\tc\td\te", "    z   y       x       w       v"])]])
 | 
			
		||||
    feed_command([[/^\s*a]])
 | 
			
		||||
    feed('fbgjyl')
 | 
			
		||||
    execute('let line1 = @0')
 | 
			
		||||
    execute([[?^\s*z]])
 | 
			
		||||
    feed_command('let line1 = @0')
 | 
			
		||||
    feed_command([[?^\s*z]])
 | 
			
		||||
    feed('fygjyl')
 | 
			
		||||
    execute('let line2 = @0')
 | 
			
		||||
    execute('quit!')
 | 
			
		||||
    execute([[$put ='Test 13: breakindent with wrapping Tab']])
 | 
			
		||||
    execute('$put =line1')
 | 
			
		||||
    execute('$put =line2')
 | 
			
		||||
    feed_command('let line2 = @0')
 | 
			
		||||
    feed_command('quit!')
 | 
			
		||||
    feed_command([[$put ='Test 13: breakindent with wrapping Tab']])
 | 
			
		||||
    feed_command('$put =line1')
 | 
			
		||||
    feed_command('$put =line2')
 | 
			
		||||
 | 
			
		||||
    execute('let g:test="Test 14: breakindent + visual blockwise delete #1"')
 | 
			
		||||
    execute('set all& breakindent shada+=nX-test-breakindent.shada')
 | 
			
		||||
    execute('30vnew')
 | 
			
		||||
    execute('normal! 3a1234567890')
 | 
			
		||||
    execute('normal! a    abcde')
 | 
			
		||||
    execute([[exec "normal! 0\<C-V>tex"]])
 | 
			
		||||
    execute('let line1=ScreenChar(line("."),8)')
 | 
			
		||||
    execute('call DoRecordScreen()')
 | 
			
		||||
    feed_command('let g:test="Test 14: breakindent + visual blockwise delete #1"')
 | 
			
		||||
    feed_command('set all& breakindent shada+=nX-test-breakindent.shada')
 | 
			
		||||
    feed_command('30vnew')
 | 
			
		||||
    feed_command('normal! 3a1234567890')
 | 
			
		||||
    feed_command('normal! a    abcde')
 | 
			
		||||
    feed_command([[exec "normal! 0\<C-V>tex"]])
 | 
			
		||||
    feed_command('let line1=ScreenChar(line("."),8)')
 | 
			
		||||
    feed_command('call DoRecordScreen()')
 | 
			
		||||
 | 
			
		||||
    execute('let g:test="Test 15: breakindent + visual blockwise delete #2"')
 | 
			
		||||
    execute('%d')
 | 
			
		||||
    execute('normal! 4a1234567890')
 | 
			
		||||
    execute([[exec "normal! >>\<C-V>3f0x"]])
 | 
			
		||||
    execute('let line1=ScreenChar(line("."),20)')
 | 
			
		||||
    execute('call DoRecordScreen()')
 | 
			
		||||
    execute('quit!')
 | 
			
		||||
    feed_command('let g:test="Test 15: breakindent + visual blockwise delete #2"')
 | 
			
		||||
    feed_command('%d')
 | 
			
		||||
    feed_command('normal! 4a1234567890')
 | 
			
		||||
    feed_command([[exec "normal! >>\<C-V>3f0x"]])
 | 
			
		||||
    feed_command('let line1=ScreenChar(line("."),20)')
 | 
			
		||||
    feed_command('call DoRecordScreen()')
 | 
			
		||||
    feed_command('quit!')
 | 
			
		||||
 | 
			
		||||
    -- Assert buffer contents.
 | 
			
		||||
    expect([[
 | 
			
		||||
 
 | 
			
		||||
@@ -3,7 +3,7 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local clear, feed, insert = helpers.clear, helpers.feed, helpers.insert
 | 
			
		||||
local execute, expect = helpers.execute, helpers.expect
 | 
			
		||||
local feed_command, expect = helpers.feed_command, helpers.expect
 | 
			
		||||
 | 
			
		||||
describe('changelist', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
@@ -12,14 +12,14 @@ describe('changelist', function()
 | 
			
		||||
    insert("1\n2")
 | 
			
		||||
 | 
			
		||||
    feed('Gkylp')
 | 
			
		||||
    execute('set ul=100')
 | 
			
		||||
    feed_command('set ul=100')
 | 
			
		||||
 | 
			
		||||
    feed('Gylp')
 | 
			
		||||
    execute('set ul=100')
 | 
			
		||||
    feed_command('set ul=100')
 | 
			
		||||
 | 
			
		||||
    feed('gg')
 | 
			
		||||
    execute('vsplit')
 | 
			
		||||
    execute('try', 'normal g;', 'normal ggVGcpass', 'catch', 'normal ggVGcfail', 'endtry')
 | 
			
		||||
    feed_command('vsplit')
 | 
			
		||||
    feed_command('try', 'normal g;', 'normal ggVGcpass', 'catch', 'normal ggVGcfail', 'endtry')
 | 
			
		||||
 | 
			
		||||
    expect('pass')
 | 
			
		||||
  end)
 | 
			
		||||
 
 | 
			
		||||
@@ -2,7 +2,7 @@
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local feed, insert = helpers.feed, helpers.insert
 | 
			
		||||
local clear, execute, expect = helpers.clear, helpers.execute, helpers.expect
 | 
			
		||||
local clear, feed_command, expect = helpers.clear, helpers.feed_command, helpers.expect
 | 
			
		||||
 | 
			
		||||
describe('charsearch', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
@@ -14,23 +14,23 @@ describe('charsearch', function()
 | 
			
		||||
      Zabcdefghijkemnokqretkvwxyz]])
 | 
			
		||||
 | 
			
		||||
    -- Check that "fe" and ";" work.
 | 
			
		||||
    execute('/^X')
 | 
			
		||||
    feed_command('/^X')
 | 
			
		||||
    feed('ylfep;;p,,p')
 | 
			
		||||
    -- Check that save/restore works.
 | 
			
		||||
    execute('/^Y')
 | 
			
		||||
    feed_command('/^Y')
 | 
			
		||||
    feed('ylfep')
 | 
			
		||||
    execute('let csave = getcharsearch()')
 | 
			
		||||
    feed_command('let csave = getcharsearch()')
 | 
			
		||||
    feed('fip')
 | 
			
		||||
    execute('call setcharsearch(csave)')
 | 
			
		||||
    feed_command('call setcharsearch(csave)')
 | 
			
		||||
    feed(';p;p')
 | 
			
		||||
    -- Check that setcharsearch() changes the settings.
 | 
			
		||||
    execute('/^Z')
 | 
			
		||||
    feed_command('/^Z')
 | 
			
		||||
    feed('ylfep')
 | 
			
		||||
    execute("call setcharsearch({'char': 'k'})")
 | 
			
		||||
    feed_command("call setcharsearch({'char': 'k'})")
 | 
			
		||||
    feed(';p')
 | 
			
		||||
    execute("call setcharsearch({'forward': 0})")
 | 
			
		||||
    feed_command("call setcharsearch({'forward': 0})")
 | 
			
		||||
    feed('$;p')
 | 
			
		||||
    execute("call setcharsearch({'until': 1})")
 | 
			
		||||
    feed_command("call setcharsearch({'until': 1})")
 | 
			
		||||
    feed(';;p')
 | 
			
		||||
 | 
			
		||||
    -- Assert buffer contents.
 | 
			
		||||
 
 | 
			
		||||
@@ -1,133 +1,141 @@
 | 
			
		||||
-- Tests for :[count]close! and :[count]hide
 | 
			
		||||
 | 
			
		||||
local helpers = require('test.functional.helpers')(after_each)
 | 
			
		||||
local feed, eval, eq, clear, execute =
 | 
			
		||||
  helpers.feed, helpers.eval, helpers.eq, helpers.clear, helpers.execute
 | 
			
		||||
 | 
			
		||||
local eq = helpers.eq
 | 
			
		||||
local wait = helpers.wait
 | 
			
		||||
local feed = helpers.feed
 | 
			
		||||
local clear = helpers.clear
 | 
			
		||||
local command = helpers.command
 | 
			
		||||
 | 
			
		||||
describe('close_count', function()
 | 
			
		||||
  setup(clear)
 | 
			
		||||
 | 
			
		||||
  it('is working', function()
 | 
			
		||||
    execute('let tests = []')
 | 
			
		||||
    execute('for i in range(5)')
 | 
			
		||||
    execute('new')
 | 
			
		||||
    execute('endfor')
 | 
			
		||||
    execute('4wincmd w')
 | 
			
		||||
    execute('close!')
 | 
			
		||||
    execute('let buffers = []')
 | 
			
		||||
    execute('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    command('let tests = []')
 | 
			
		||||
    command('for i in range(5)')
 | 
			
		||||
    command('new')
 | 
			
		||||
    command('endfor')
 | 
			
		||||
    command('4wincmd w')
 | 
			
		||||
    command('close!')
 | 
			
		||||
    command('let buffers = []')
 | 
			
		||||
    command('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    eq({6, 5, 4, 2, 1}, eval('buffers'))
 | 
			
		||||
    execute('1close!')
 | 
			
		||||
    execute('let buffers = []')
 | 
			
		||||
    execute('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    command('1close!')
 | 
			
		||||
    command('let buffers = []')
 | 
			
		||||
    command('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    eq({5, 4, 2, 1}, eval('buffers'))
 | 
			
		||||
    execute('$close!')
 | 
			
		||||
    execute('let buffers = []')
 | 
			
		||||
    execute('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    command('$close!')
 | 
			
		||||
    command('let buffers = []')
 | 
			
		||||
    command('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    eq({5, 4, 2}, eval('buffers'))
 | 
			
		||||
    execute('1wincmd w')
 | 
			
		||||
    execute('2close!')
 | 
			
		||||
    execute('let buffers = []')
 | 
			
		||||
    execute('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    command('1wincmd w')
 | 
			
		||||
    command('2close!')
 | 
			
		||||
    command('let buffers = []')
 | 
			
		||||
    command('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    eq({5, 2}, eval('buffers'))
 | 
			
		||||
    execute('1wincmd w')
 | 
			
		||||
    execute('new')
 | 
			
		||||
    execute('new')
 | 
			
		||||
    execute('2wincmd w')
 | 
			
		||||
    execute('-1close!')
 | 
			
		||||
    execute('let buffers = []')
 | 
			
		||||
    execute('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    command('1wincmd w')
 | 
			
		||||
    command('new')
 | 
			
		||||
    command('new')
 | 
			
		||||
    command('2wincmd w')
 | 
			
		||||
    command('-1close!')
 | 
			
		||||
    command('let buffers = []')
 | 
			
		||||
    command('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    eq({7, 5, 2}, eval('buffers'))
 | 
			
		||||
    execute('2wincmd w')
 | 
			
		||||
    execute('+1close!')
 | 
			
		||||
    execute('let buffers = []')
 | 
			
		||||
    execute('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    command('2wincmd w')
 | 
			
		||||
    command('+1close!')
 | 
			
		||||
    command('let buffers = []')
 | 
			
		||||
    command('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    eq({7, 5}, eval('buffers'))
 | 
			
		||||
    execute('only!')
 | 
			
		||||
    execute('b1')
 | 
			
		||||
    execute('let tests = []')
 | 
			
		||||
    execute('for i in range(5)')
 | 
			
		||||
    execute('new')
 | 
			
		||||
    execute('endfor')
 | 
			
		||||
    execute('let buffers = []')
 | 
			
		||||
    execute('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    command('only!')
 | 
			
		||||
    command('b1')
 | 
			
		||||
    command('let tests = []')
 | 
			
		||||
    command('for i in range(5)')
 | 
			
		||||
    command('new')
 | 
			
		||||
    command('endfor')
 | 
			
		||||
    command('let buffers = []')
 | 
			
		||||
    command('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    eq({13, 12, 11, 10, 9, 1}, eval('buffers'))
 | 
			
		||||
    execute('4wincmd w')
 | 
			
		||||
    execute('.hide')
 | 
			
		||||
    execute('let buffers = []')
 | 
			
		||||
    execute('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    command('4wincmd w')
 | 
			
		||||
    command('.hide')
 | 
			
		||||
    command('let buffers = []')
 | 
			
		||||
    command('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    eq({13, 12, 11, 9, 1}, eval('buffers'))
 | 
			
		||||
    execute('1hide')
 | 
			
		||||
    execute('let buffers = []')
 | 
			
		||||
    execute('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    command('1hide')
 | 
			
		||||
    command('let buffers = []')
 | 
			
		||||
    command('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    eq({12, 11, 9, 1}, eval('buffers'))
 | 
			
		||||
    execute('$hide')
 | 
			
		||||
    execute('let buffers = []')
 | 
			
		||||
    execute('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    command('$hide')
 | 
			
		||||
    command('let buffers = []')
 | 
			
		||||
    command('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    eq({12, 11, 9}, eval('buffers'))
 | 
			
		||||
    execute('1wincmd w')
 | 
			
		||||
    execute('2hide')
 | 
			
		||||
    execute('let buffers = []')
 | 
			
		||||
    execute('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    command('1wincmd w')
 | 
			
		||||
    command('2hide')
 | 
			
		||||
    command('let buffers = []')
 | 
			
		||||
    command('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    eq({12, 9}, eval('buffers'))
 | 
			
		||||
    execute('1wincmd w')
 | 
			
		||||
    execute('new')
 | 
			
		||||
    execute('new')
 | 
			
		||||
    execute('3wincmd w')
 | 
			
		||||
    execute('-hide')
 | 
			
		||||
    execute('let buffers = []')
 | 
			
		||||
    execute('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    command('1wincmd w')
 | 
			
		||||
    command('new')
 | 
			
		||||
    command('new')
 | 
			
		||||
    command('3wincmd w')
 | 
			
		||||
    command('-hide')
 | 
			
		||||
    command('let buffers = []')
 | 
			
		||||
    command('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    eq({15, 12, 9}, eval('buffers'))
 | 
			
		||||
    execute('2wincmd w')
 | 
			
		||||
    execute('+hide')
 | 
			
		||||
    execute('let buffers = []')
 | 
			
		||||
    execute('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    command('2wincmd w')
 | 
			
		||||
    command('+hide')
 | 
			
		||||
    command('let buffers = []')
 | 
			
		||||
    command('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    eq({15, 12}, eval('buffers'))
 | 
			
		||||
    execute('only!')
 | 
			
		||||
    execute('b1')
 | 
			
		||||
    execute('let tests = []')
 | 
			
		||||
    execute('set hidden')
 | 
			
		||||
    execute('for i in range(5)')
 | 
			
		||||
    execute('new')
 | 
			
		||||
    execute('endfor')
 | 
			
		||||
    execute('1wincmd w')
 | 
			
		||||
    execute('$ hide')
 | 
			
		||||
    execute('let buffers = []')
 | 
			
		||||
    execute('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    command('only!')
 | 
			
		||||
    command('b1')
 | 
			
		||||
    command('let tests = []')
 | 
			
		||||
    command('set hidden')
 | 
			
		||||
    command('for i in range(5)')
 | 
			
		||||
    command('new')
 | 
			
		||||
    command('endfor')
 | 
			
		||||
    command('1wincmd w')
 | 
			
		||||
    command('$ hide')
 | 
			
		||||
    command('let buffers = []')
 | 
			
		||||
    command('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    eq({20, 19, 18, 17, 16}, eval('buffers'))
 | 
			
		||||
    execute('$-1 close!')
 | 
			
		||||
    execute('let buffers = []')
 | 
			
		||||
    execute('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    command('$-1 close!')
 | 
			
		||||
    command('let buffers = []')
 | 
			
		||||
    command('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    eq({20, 19, 18, 16}, eval('buffers'))
 | 
			
		||||
    execute('1wincmd w')
 | 
			
		||||
    execute('.+close!')
 | 
			
		||||
    execute('let buffers = []')
 | 
			
		||||
    execute('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    command('1wincmd w')
 | 
			
		||||
    command('.+close!')
 | 
			
		||||
    command('let buffers = []')
 | 
			
		||||
    command('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    eq({20, 18, 16}, eval('buffers'))
 | 
			
		||||
    execute('only!')
 | 
			
		||||
    execute('b1')
 | 
			
		||||
    execute('let tests = []')
 | 
			
		||||
    execute('set hidden')
 | 
			
		||||
    execute('for i in range(5)')
 | 
			
		||||
    execute('new')
 | 
			
		||||
    execute('endfor')
 | 
			
		||||
    execute('4wincmd w')
 | 
			
		||||
    command('only!')
 | 
			
		||||
    command('b1')
 | 
			
		||||
    command('let tests = []')
 | 
			
		||||
    command('set hidden')
 | 
			
		||||
    command('for i in range(5)')
 | 
			
		||||
    command('new')
 | 
			
		||||
    command('endfor')
 | 
			
		||||
    command('4wincmd w')
 | 
			
		||||
    feed('<C-W>c<cr>')
 | 
			
		||||
    execute('let buffers = []')
 | 
			
		||||
    execute('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('let buffers = []')
 | 
			
		||||
    command('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    eq({25, 24, 23, 21, 1}, eval('buffers'))
 | 
			
		||||
    feed('1<C-W>c<cr>')
 | 
			
		||||
    execute('let buffers = []')
 | 
			
		||||
    execute('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('let buffers = []')
 | 
			
		||||
    command('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    eq({24, 23, 21, 1}, eval('buffers'))
 | 
			
		||||
    feed('9<C-W>c<cr>')
 | 
			
		||||
    execute('let buffers = []')
 | 
			
		||||
    execute('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('let buffers = []')
 | 
			
		||||
    command('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    eq({24, 23, 21}, eval('buffers'))
 | 
			
		||||
    execute('1wincmd w')
 | 
			
		||||
    command('1wincmd w')
 | 
			
		||||
    feed('2<C-W>c<cr>')
 | 
			
		||||
    execute('let buffers = []')
 | 
			
		||||
    execute('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    wait()
 | 
			
		||||
    command('let buffers = []')
 | 
			
		||||
    command('windo call add(buffers, bufnr("%"))')
 | 
			
		||||
    eq({24, 21}, eval('buffers'))
 | 
			
		||||
  end)
 | 
			
		||||
end)
 | 
			
		||||
 
 | 
			
		||||
Some files were not shown because too many files have changed in this diff Show More
		Reference in New Issue
	
	Block a user