You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1148 lines
39 KiB
1148 lines
39 KiB
Include: include/setup.vader |
|
|
|
Execute (NeomakeTestsCreateExe creates exe): |
|
Assert !executable('boobar'), 'boobar is not executable' |
|
call g:NeomakeTestsCreateExe('boobar', []) |
|
Assert executable('boobar'), 'boobar is now executable' |
|
|
|
Execute (NeomakeTestsCreateExe overrides existing exe): |
|
let true = system('which true') |
|
Assert executable('true'), 'true is now executable' |
|
call g:NeomakeTestsCreateExe('true', []) |
|
AssertNotEqual system('which true'), true |
|
|
|
Execute (neomake#utils#GetSetting serialize): |
|
let s:maker = {'name': 'mymaker'} |
|
function! s:GetSetting() |
|
return neomake#utils#GetSetting('serialize', s:maker, 'default', |
|
\ 'myft', bufnr('%')) |
|
endfunction |
|
|
|
new |
|
" Do not trigger checking new-style config. |
|
Save g:neomake |
|
unlet! g:neomake |
|
|
|
Save g:neomake_serialize, b:neomake_serialize |
|
Save g:neomake_mymaker_serialize, b:neomake_mymaker_serialize |
|
Save g:neomake_myft_mymaker_serialize, b:neomake_myft_mymaker_serialize |
|
|
|
AssertEqual s:GetSetting(), 'default' |
|
|
|
let g:neomake_serialize = 7 |
|
AssertEqual s:GetSetting(), 7 |
|
" maker-only should return default. |
|
AssertEqual neomake#utils#GetSetting('serialize', s:maker, 'default', |
|
\ 'myft', bufnr('%'), 1), 'default' |
|
let g:neomake_serialize = 0 |
|
AssertEqual s:GetSetting(), 0 |
|
let g:neomake_serialize = 99 |
|
AssertEqual s:GetSetting(), 99 |
|
|
|
let b:neomake_serialize = 6 |
|
AssertEqual s:GetSetting(), 6 |
|
let b:neomake_serialize = 0 |
|
AssertEqual s:GetSetting(), 0 |
|
let b:neomake_serialize = 98 |
|
AssertEqual s:GetSetting(), 98 |
|
|
|
let s:maker.serialize = 5 |
|
AssertEqual s:GetSetting(), 5 |
|
let s:maker.serialize = 0 |
|
AssertEqual s:GetSetting(), 0 |
|
let s:maker.serialize = 97 |
|
AssertEqual s:GetSetting(), 97 |
|
|
|
" Falls back correctly to old-style setting with new-style from maker. |
|
let g:neomake = {} |
|
AssertEqual s:GetSetting(), 97 |
|
unlet g:neomake |
|
|
|
let g:neomake_mymaker_serialize = 4 |
|
AssertEqual s:GetSetting(), 4 |
|
let g:neomake_mymaker_serialize = 0 |
|
AssertEqual s:GetSetting(), 0 |
|
let g:neomake_mymaker_serialize = 96 |
|
AssertEqual s:GetSetting(), 96 |
|
|
|
let b:neomake_mymaker_serialize = 3 |
|
AssertEqual s:GetSetting(), 3 |
|
let b:neomake_mymaker_serialize = 0 |
|
AssertEqual s:GetSetting(), 0 |
|
let b:neomake_mymaker_serialize = 95 |
|
AssertEqual s:GetSetting(), 95 |
|
|
|
let g:neomake_myft_mymaker_serialize = 2 |
|
AssertEqual s:GetSetting(), 2 |
|
let g:neomake_myft_mymaker_serialize = 0 |
|
AssertEqual s:GetSetting(), 0 |
|
let g:neomake_myft_mymaker_serialize = 94 |
|
AssertEqual s:GetSetting(), 94 |
|
|
|
let b:neomake_myft_mymaker_serialize = 1 |
|
AssertEqual s:GetSetting(), 1 |
|
let b:neomake_myft_mymaker_serialize = 0 |
|
AssertEqual s:GetSetting(), 0 |
|
unlet b:neomake_myft_mymaker_serialize |
|
let b:neomake_myft_mymaker_serialize = [1] |
|
AssertEqual s:GetSetting(), [1] |
|
|
|
" Uses b:neomake_serialize |
|
let s:maker = {'name': ''} |
|
AssertEqual s:GetSetting(), 98 |
|
let s:maker = {} |
|
AssertEqual s:GetSetting(), 98 |
|
bwipe |
|
|
|
Execute (neomake#utils#GetSetting handles maker-only settings): |
|
new |
|
set filetype=myft |
|
AssertEqual 'default', neomake#utils#GetSetting('exe', {}, 'default', 'myft', bufnr('%')) |
|
let b:neomake_exe = 'buffer_exe' |
|
AssertEqual 'buffer_exe', neomake#utils#GetSetting('exe', {}, 'default', 'myft', bufnr('%')) |
|
AssertEqual 'default', neomake#utils#GetSetting('exe', {}, 'default', 'myft', bufnr('%'), 1) |
|
|
|
let b:neomake_myft_mymaker_maker = {} |
|
AssertEqual neomake#GetMaker('mymaker', 'myft').exe, 'mymaker' |
|
bwipe |
|
|
|
Execute (neomake#utils#GetSetting handles maker-only settings (dict-config)): |
|
new |
|
set filetype=myft |
|
AssertEqual 'default', neomake#utils#GetSetting('exe', {}, 'default', 'myft', bufnr('%')) |
|
let b:neomake = {'exe': 'buffer_exe'} |
|
AssertEqual 'buffer_exe', neomake#utils#GetSetting('exe', {}, 'default', 'myft', bufnr('%')) |
|
AssertEqual 'default', neomake#utils#GetSetting('exe', {}, 'default', 'myft', bufnr('%'), 1) |
|
|
|
call neomake#config#set('b:ft.myft.mymaker.maker', {}) |
|
AssertEqual neomake#GetMaker('mymaker', 'myft').exe, 'mymaker' |
|
call neomake#config#set('b:ft.myft.mymaker.maker', {'exe': 'foo'}) |
|
AssertEqual neomake#GetMaker('mymaker', 'myft').exe, 'foo' |
|
|
|
let maker = {} |
|
AssertEqual neomake#config#get('mymaker.exe', 'default', {'ft': 'myft', 'bufnr': bufnr('%')}), 'default' |
|
let maker = {'exe': 'maker_exe'} |
|
AssertEqual neomake#config#get('mymaker.exe', 'default', {'ft': 'myft', 'bufnr': bufnr('%'), 'maker': maker}), 'default' |
|
let maker = {'name': 'mymaker', 'exe': 'maker_exe'} |
|
AssertEqual neomake#config#get('mymaker.exe', 'default', {'ft': 'myft', 'bufnr': bufnr('%'), 'maker': maker}), 'maker_exe' |
|
bwipe |
|
|
|
Execute (neomake#utils#GetSetting uses old-style g: with bufnr ''): |
|
Save g:neomake_mysetting |
|
let g:neomake_mysetting = 1 |
|
AssertEqual neomake#utils#GetSetting('mysetting', {}, 'default', 'myft', ''), 1 |
|
let g:neomake_myft_mysetting = 2 |
|
AssertEqual neomake#utils#GetSetting('mysetting', {}, 'default', 'myft', ''), 2 |
|
let g:neomake_myft_mymaker_mysetting = 3 |
|
AssertEqual neomake#utils#GetSetting('mysetting', {'name': 'mymaker'}, 'default', 'myft', ''), 3 |
|
|
|
Execute (neomake#utils#GetSetting for multiple fts): |
|
new |
|
function! s:GetSetting(key) |
|
return neomake#utils#GetSetting(a:key, {}, 'default', |
|
\ 'jsx.javascript', bufnr('%')) |
|
endfunction |
|
let b:neomake_jsx_javascript_setting = '1' |
|
AssertEqual s:GetSetting('setting'), '1' |
|
bwipe |
|
|
|
Execute (neomake#utils#GetSetting for multiple fts (new-style)): |
|
new |
|
function! s:GetSetting(key) |
|
return neomake#utils#GetSetting(a:key, {}, 'default', |
|
\ 'jsx.javascript', bufnr('%')) |
|
endfunction |
|
call neomake#config#set_buffer(bufnr('%'), ['ft', 'jsx.javascript', 'setting'], 1) |
|
AssertEqual s:GetSetting('setting'), 1 |
|
call neomake#config#set(['b:ft', 'jsx.javascript', 'setting'], 2) |
|
AssertEqual s:GetSetting('setting'), 2 |
|
let b:neomake = {'ft': {'jsx.javascript': {'setting': 3}}} |
|
AssertEqual s:GetSetting('setting'), 3 |
|
let b:neomake = {'ft': {'jsx': {'setting': 4}}} |
|
AssertEqual s:GetSetting('setting'), 4 |
|
let b:neomake = {'ft': {'javascript': {'setting': 5}}} |
|
AssertEqual s:GetSetting('setting'), 5 |
|
let b:neomake = {'ft': {'javascript.jsx': {'setting': 6}}} |
|
AssertEqual s:GetSetting('setting'), 'default' |
|
bwipe |
|
|
|
Execute (neomake#utils#GetSetting accepts lists): |
|
Save g:maker |
|
let g:maker = {'name': 'mymaker'} |
|
function! s:GetSetting() |
|
return neomake#utils#GetSetting('args', g:maker, 'default', |
|
\ 'myft', bufnr('%')) |
|
endfunction |
|
|
|
Save g:neomake_myft_mymaker_args, b:neomake_myft_mymaker_args |
|
let g:neomake_myft_mymaker_args = [ 'global', 'shallow', 'list' ] |
|
AssertEqual s:GetSetting(), [ 'global', 'shallow', 'list' ] |
|
let b:neomake_myft_mymaker_args = [ 'buffer', 'shallow', 'list' ] |
|
AssertEqual s:GetSetting(), [ 'buffer', 'shallow', 'list' ] |
|
|
|
Save g:maker |
|
Restore |
|
let g:maker = {'name': 'mymaker'} |
|
Save b:neomake_myft_mymaker_args |
|
let b:neomake_myft_mymaker_args = 'string' |
|
AssertEqual s:GetSetting(), 'string' |
|
|
|
Execute (neomake#utils#GetSetting without name): |
|
Save g:maker |
|
let g:maker = {} |
|
function! s:GetSetting(key) |
|
return neomake#utils#GetSetting(a:key, g:maker, [], |
|
\ 'myft', bufnr('%')) |
|
endfunction |
|
AssertEqual s:GetSetting('args'), [] |
|
|
|
Save g:neomake_setting, g:neomake_myft_setting |
|
AssertEqual s:GetSetting('setting'), [] |
|
let g:neomake_setting = 42 |
|
AssertEqual s:GetSetting('setting'), 42 |
|
let g:neomake_myft_setting = {'custom': 1} |
|
AssertEqual s:GetSetting('setting'), {'custom': 1} |
|
|
|
Execute (neomake#utils#GetSetting with new-style config): |
|
new |
|
set ft=neomake_tests |
|
|
|
let b:neomake_neomake_tests_foo = 'bar' |
|
let maker = {'name': 'mymaker', 'foo': 'from-maker'} |
|
AssertEqual neomake#utils#GetSetting( |
|
\ 'foo', maker, -1, 'neomake_tests', bufnr('%')), 'from-maker' |
|
|
|
let b:neomake_neomake_tests_mymaker_foo = 'bar' |
|
AssertEqual neomake#utils#GetSetting( |
|
\ 'foo', maker, -1, 'neomake_tests', bufnr('%')), 'bar' |
|
|
|
" New-style global setting overrides old-style buffer setting! |
|
call neomake#config#set('ft.neomake_tests.foo', 'new_bar') |
|
AssertEqual neomake#utils#GetSetting( |
|
\ 'foo', maker, -1, 'neomake_tests', bufnr('%')), 'new_bar' |
|
AssertNeomakeMessage "Using setting foo='new_bar' from 'global' (prefix: ['ft', 'neomake_tests'])." |
|
|
|
call neomake#config#set('ft.neomake_tests.foo', function('tr')) |
|
AssertEqual neomake#utils#GetSetting( |
|
\ 'foo', maker, -1, 'neomake_tests', bufnr('%')), function('tr') |
|
AssertNeomakeMessage "Using setting foo=function('tr') from 'global' (prefix: ['ft', 'neomake_tests'])." |
|
bwipe |
|
|
|
Execute (neomake#utils#GetSetting does not create a partial for dict funcs): |
|
" Ref: https://github.com/neovim/neovim/issues/7432#issuecomment-338513967 |
|
let maker = {} |
|
function maker.func() |
|
endfunction |
|
|
|
let l:Func = neomake#utils#GetSetting('func', maker, '', '', '', 1) |
|
AssertEqual type(Func), type(function('tr')) |
|
AssertEqual Func, get(maker, 'func') |
|
|
|
let l:Func = neomake#utils#GetSetting('func', maker, '', '', '', 0) |
|
AssertEqual type(Func), type(function('tr')) |
|
AssertEqual Func, get(maker, 'func') |
|
|
|
Execute (neomake#utils#GetSetting (old-style) can ignore buffer): |
|
new |
|
let bufnr = bufnr('%') |
|
noautocmd set filetype=neomake_tests |
|
let b:neomake_foo = 42 |
|
let b:neomake_neomake_tests_foo = 43 |
|
|
|
AssertEqual neomake#utils#GetSetting('foo', {}, 'default', '', bufnr), 42 |
|
AssertEqual neomake#utils#GetSetting('foo', {}, 'default', &ft, bufnr), 43 |
|
|
|
" 0 is the alternate buffer for the current window. |
|
new |
|
AssertEqual neomake#utils#GetSetting('foo', {}, 'default', '', 0), 42 |
|
AssertEqual neomake#utils#GetSetting('foo', {}, 'default', 'neomake_tests', 0), 43 |
|
|
|
" Empty string ignores the buffer. |
|
AssertEqual neomake#utils#GetSetting('foo', {}, 'default', '', ''), 'default' |
|
AssertEqual neomake#utils#GetSetting('foo', {}, 'default', 'neomake_tests', ''), 'default' |
|
bwipe |
|
bwipe |
|
|
|
Execute (neomake#utils#GetSetting prefers g: over maker): |
|
let maker = {'name': 'mymaker', 'uses_stdin': 1} |
|
new |
|
let bufnr = bufnr('%') |
|
|
|
let g:neomake_dockerfile_mymaker_uses_stdin = 0 |
|
|
|
" Old-style. |
|
AssertEqual neomake#utils#GetSetting('uses_stdin', maker, -1, 'dockerfile', bufnr), 0 |
|
|
|
" With existing new-style. |
|
let g:neomake = {} |
|
AssertEqual neomake#utils#GetSetting('uses_stdin', maker, -1, 'dockerfile', bufnr), 0 |
|
|
|
" Handles maker_only=1, i.e. does not use setting without maker prefix. |
|
call neomake#config#set('ft.dockerfile.uses_stdin', 'ignored') |
|
AssertEqual neomake#utils#GetSetting('uses_stdin', maker, -1, 'dockerfile', bufnr, 1), 1 |
|
|
|
" Prefers new-style global setting. |
|
call neomake#config#set('ft.dockerfile.mymaker.uses_stdin', 3) |
|
AssertEqual neomake#utils#GetSetting('uses_stdin', maker, -1, 'dockerfile', bufnr), 3 |
|
bwipe |
|
|
|
Execute(neomake#utils#redir): |
|
command! NeomakeTestCommand echo 1 | echo 2 |
|
command! NeomakeTestErrorCommand echoerr 'error' |
|
AssertEqual neomake#utils#redir('echon 1'), "1" |
|
AssertEqual neomake#utils#redir('echo 1'), "\n1" |
|
AssertEqual neomake#utils#redir('NeomakeTestCommand'), "\n1\n2" |
|
AssertThrows call neomake#utils#redir('NeomakeTestErrorCommand') |
|
if exists('g:vader_exception') |
|
" https://github.com/junegunn/vader.vim/issues/86 |
|
AssertEqual g:vader_exception, 'Vim(echoerr):error' |
|
endif |
|
AssertEqual neomake#utils#redir(['NeomakeTestCommand', 'echon 3']), "\n1\n23" |
|
AssertThrows neomake#utils#redir(['NeomakeTestCommand', 'echoerr 3']) |
|
|
|
Execute(neomake#utils#redir: recursive use without execute()): |
|
if exists('*execute') && has('nvim-0.2.0') |
|
AssertEqual neomake#utils#redir('echon neomake#utils#redir("echon 1")'), '1' |
|
else |
|
AssertThrows call neomake#utils#redir('echon neomake#utils#redir("echon 1")') |
|
AssertEqual g:vader_exception, 'Neomake: neomake#utils#redir: called with outer :redir (error: Vim(redir):E121: Undefined variable: neomake_redir).' |
|
|
|
try |
|
redir => outer_output |
|
AssertThrows call neomake#utils#redir('echon neomake#utils#redir("echon 1")') |
|
AssertEqual g:vader_exception, 'Neomake: neomake#utils#redir: called with outer :redir (error: Vim(redir):E121: Undefined variable: outer_output).' |
|
finally |
|
redir END |
|
endtry |
|
endif |
|
|
|
Execute (neomake#utils#ExpandArgs): |
|
Save $HOME |
|
let $HOME='/home/sweet' |
|
|
|
new |
|
file file1.ext |
|
let isk = &iskeyword |
|
let args = [ |
|
\ '%', |
|
\ '%:h', |
|
\ '%:p:t:r', |
|
\ '%:rt', |
|
\ '--foo=%:h', |
|
\ '%s', |
|
\ '%z', |
|
\ '\%', |
|
\ '%%', |
|
\ '%%NEOMAKE_FILE%%', |
|
\ '%:r.o', |
|
\ '%:r%', |
|
\ '%:r% %', |
|
\ '%%%%', |
|
\ '%%%', |
|
\ '^%$', |
|
\ 'C:\\%\\', |
|
\ 'C:\\%:r\\', |
|
\ '~', |
|
\ '\~', |
|
\ 't/~=+.view.vim', |
|
\ '~/foo', |
|
\ '~/', |
|
\ '~foo', |
|
\ '%:.', |
|
\ '%:,', |
|
\ '%<', |
|
\ ] |
|
let expected_args = [ |
|
\ 'file1.ext', |
|
\ '.', |
|
\ 'file1', |
|
\ 'file1t', |
|
\ '--foo=.', |
|
\ '%s', |
|
\ '%z', |
|
\ '\%', |
|
\ '%', |
|
\ '%NEOMAKE_FILE%', |
|
\ 'file1.o', |
|
\ 'file1file1.ext', |
|
\ 'file1file1.ext file1.ext', |
|
\ '%%', |
|
\ '%file1.ext', |
|
\ '^file1.ext$', |
|
\ 'C:\\file1.ext\\', |
|
\ 'C:\\file1\\', |
|
\ '/home/sweet', |
|
\ '\~', |
|
\ 't/~=+.view.vim', |
|
\ '/home/sweet/foo', |
|
\ '/home/sweet/', |
|
\ '~foo', |
|
\ 'file1.ext', |
|
\ 'file1.ext:,', |
|
\ 'file1', |
|
\ ] |
|
|
|
let jobinfo = {'bufnr': bufnr('%')} |
|
AssertEqual expected_args, neomake#utils#ExpandArgs(args, jobinfo) |
|
AssertEqual isk, &iskeyword |
|
bwipe |
|
|
|
Execute (neomake#utils#ExpandArgs: :S): |
|
if !has('patch-7.4.191') |
|
NeomakeTestsSkip 'Only with 7.4.191+' |
|
else |
|
new |
|
file file1.ext |
|
let jobinfo = {'bufnr': bufnr('%')} |
|
AssertEqual neomake#utils#ExpandArgs(['%:S'], jobinfo), ["'file1.ext'"] |
|
bwipe |
|
endif |
|
|
|
Execute (neomake#utils#ExpandArgs: %t for temporary file): |
|
new |
|
let jobinfo = {'bufnr': bufnr('%')} |
|
AssertEqual neomake#utils#ExpandArgs(['%t'], jobinfo), [''] |
|
|
|
file fname.ext |
|
AssertEqual neomake#utils#ExpandArgs(['%t'], jobinfo), [fnamemodify('fname.ext', ':p')] |
|
|
|
let jobinfo.tempfile = '/some/temp.file' |
|
AssertEqual neomake#utils#ExpandArgs(['%t'], jobinfo), ['/some/temp.file'] |
|
" Does not get fnamemodified. |
|
AssertEqual neomake#utils#ExpandArgs(['%t:h'], jobinfo), ['/some/temp.file:h'] |
|
bwipe |
|
|
|
Execute (neomake#utils#ExpandArgs: from another buffer): |
|
new |
|
file file1.ext |
|
let jobinfo = {'bufnr': bufnr('%')} |
|
new |
|
AssertEqual neomake#utils#ExpandArgs(['%'], jobinfo), ['file1.ext'] |
|
AssertEqual neomake#utils#ExpandArgs(['%:e'], jobinfo), ['ext'] |
|
AssertEqual neomake#utils#ExpandArgs(['foo: %:e'], jobinfo), ['foo: ext'] |
|
bwipe |
|
bwipe |
|
|
|
Execute (neomake#utils#diff_dict): |
|
AssertEqual neomake#utils#diff_dict({}, {}), {} |
|
AssertEqual neomake#utils#diff_dict({'a': 1}, {'a': 2}), |
|
\ {'changed': {'a': [1, 2]}} |
|
AssertEqual neomake#utils#diff_dict({'a': 1}, {'b': 2}), |
|
\ {'removed': {'a': 1}, 'added': {'b': 2}} |
|
AssertEqual neomake#utils#diff_dict({'a': 1}, {'a': 1, 'b': 2}), |
|
\ {'added': {'b': 2}} |
|
|
|
AssertEqual neomake#utils#diff_dict({'a': '1'}, {'a': 1}), |
|
\ {'changed': {'a': ['1', 1]}} |
|
AssertEqual neomake#utils#diff_dict({'a': []}, {'a': {}}), |
|
\ {'changed': {'a': [[], {}]}} |
|
|
|
Execute (neomake#utils#truncate_width): |
|
AssertEqual neomake#utils#truncate_width('', 0), '' |
|
AssertEqual neomake#utils#truncate_width('', -1), '' |
|
|
|
AssertEqual neomake#utils#truncate_width('123', 0), '' |
|
AssertEqual neomake#utils#truncate_width('123', 1), '…' |
|
AssertEqual neomake#utils#truncate_width('123', 1, ''), '1' |
|
AssertEqual neomake#utils#truncate_width('123', 2), '1…' |
|
AssertEqual neomake#utils#truncate_width('123', 3), '123' |
|
AssertEqual neomake#utils#truncate_width('123', 4), '123' |
|
|
|
AssertEqual neomake#utils#truncate_width('长长的。', 0), '' |
|
AssertEqual neomake#utils#truncate_width('长长的。', 1), '…' |
|
AssertEqual neomake#utils#truncate_width('长长的。', 2), '…' |
|
AssertEqual neomake#utils#truncate_width('长长的。', 3), '长…' |
|
AssertEqual neomake#utils#truncate_width('长长的。', 4), '长…' |
|
AssertEqual neomake#utils#truncate_width('长长的。', 10), '长长的。' |
|
|
|
AssertEqual neomake#utils#truncate_width('abc。', 4), 'abc…' |
|
AssertEqual neomake#utils#truncate_width('abc。', 5), 'abc。' |
|
AssertEqual neomake#utils#truncate_width('abc。xyz', 6), 'abc。…' |
|
AssertEqual neomake#utils#truncate_width('abc。xyz', 7), 'abc。x…' |
|
|
|
" Undefined, currently acts as width=0. |
|
AssertEqual neomake#utils#truncate_width('abc', -1), '' |
|
|
|
" Longer ellipsis. |
|
AssertEqual neomake#utils#truncate_width('abc', 0, '...'), '' |
|
AssertEqual neomake#utils#truncate_width('abc', 1, '...'), '' |
|
AssertEqual neomake#utils#truncate_width('abc', 2, '...'), '' |
|
AssertEqual neomake#utils#truncate_width('abc', 3, '...'), 'abc' |
|
AssertEqual neomake#utils#truncate_width('abcde', 4, '...'), 'a...' |
|
|
|
Execute (neomake#utils#sort_by_col): |
|
function! s:sort(l) |
|
call sort(a:l, function('neomake#utils#sort_by_col')) |
|
return a:l |
|
endfunction |
|
|
|
let a = {'col': 1} |
|
let b = {'col': 5} |
|
AssertEqual s:sort([a, b]), [a, b] |
|
norm i1234 |
|
AssertEqual getpos('.')[2], 4, 'position is correct' |
|
AssertEqual s:sort([a, b]), [a, b] |
|
norm a5 |
|
AssertEqual getpos('.')[2], 5, 'position is correct' |
|
AssertEqual s:sort([a, b]), [b, a] |
|
|
|
Execute (neomake#utils#MakerFromCommand splits shell/shellcmdflag): |
|
Save &shell, &shellcmdflag |
|
|
|
let jobinfo = NeomakeTestsFakeJobinfo() |
|
let jobinfo.file_mode = 0 |
|
let jobinfo.bufnr = 0 |
|
|
|
let &shell = '/bin/bash -o pipefail' |
|
let &shellcmdflag = '-c' |
|
let maker = neomake#utils#MakerFromCommand('echo 1') |
|
if neomake#has_async_support() |
|
let expected_argv = ['/bin/bash', '-o', 'pipefail', '-c', 'echo 1'] |
|
else |
|
let expected_argv = "/bin/bash -o pipefail -c 'echo 1'" |
|
endif |
|
AssertEqual maker._get_argv(jobinfo), expected_argv |
|
|
|
let &shell = '/bin/bash' |
|
let &shellcmdflag = '-o pipefail -c' |
|
let maker = neomake#utils#MakerFromCommand('echo 2') |
|
if neomake#has_async_support() |
|
let expected_argv = ['/bin/bash', '-o', 'pipefail', '-c', 'echo 2'] |
|
else |
|
let expected_argv = "/bin/bash -o pipefail -c 'echo 2'" |
|
endif |
|
AssertEqual maker._get_argv(jobinfo), expected_argv |
|
|
|
Execute (neomake#utils#MakerFromCommand copies args): |
|
new |
|
exe 'file file_with_escaped_\%:p' |
|
let maker = neomake#utils#MakerFromCommand('echo "%" 1') |
|
let maker.tempfile_name = 'tempfile' |
|
let jobinfo = NeomakeTestsFakeJobinfo() |
|
let bound_maker = neomake#GetMaker(maker) |
|
let argv = bound_maker._get_argv(jobinfo) |
|
let shell_argv = split(&shell) + split(&shellcmdflag) |
|
if type(argv) == type([]) |
|
AssertEqual argv, shell_argv + ['echo "file_with_escaped_%:p" 1 tempfile'] |
|
else |
|
AssertEqual argv, join(shell_argv)." 'echo \"file_with_escaped_%:p\" 1 tempfile'" |
|
endif |
|
let again_argv = bound_maker._get_argv(jobinfo) |
|
AssertEqual argv, again_argv |
|
bwipe |
|
|
|
Execute (neomake#utils#MakerFromCommand appends args for file_mode (string)): |
|
let maker = neomake#utils#MakerFromCommand('printf "%s\n" "%" 1') |
|
|
|
new |
|
edit tests/fixtures/a\ filename\ with\ spaces |
|
|
|
let jobinfo = NeomakeTestsFakeJobinfo() |
|
let shell_argv = split(&shell) + split(&shellcmdflag) |
|
AssertEqual maker, { |
|
\ '__command_is_string': 1, |
|
\ '_get_argv': get(maker, '_get_argv'), |
|
\ '_get_fname_for_args': get(maker, '_get_fname_for_args'), |
|
\ 'args': shell_argv[1:] + ['printf "%s\n" "%" 1'], |
|
\ 'exe': shell_argv[0], |
|
\ 'remove_invalid_entries': 0} |
|
|
|
let fname = bufname('%') |
|
let jobinfo.maker = maker |
|
let bound_maker = neomake#GetMaker(maker) |
|
AssertEqual bound_maker.args, shell_argv[1:] + ['printf "%s\n" "%" 1'] |
|
AssertEqual bound_maker.exe, shell_argv[0] |
|
AssertEqual bound_maker.remove_invalid_entries, 0 |
|
|
|
call bound_maker._bind_args() |
|
AssertEqual bound_maker.args, shell_argv[1:] + ['printf "%s\n" "%" 1'] |
|
|
|
let argv = bound_maker._get_argv(jobinfo) |
|
if type(argv) == type([]) |
|
AssertEqual argv, shell_argv + ['printf "%s\n" "'.fname.'" 1 ''tests/fixtures/a filename with spaces'''] |
|
else |
|
AssertEqual argv, join(shell_argv).' ''printf "%s\n" "tests/fixtures/a filename with spaces" 1 ''\''''tests/fixtures/a filename with spaces''\''''''' |
|
endif |
|
" self.args is not changed. |
|
AssertEqual bound_maker.args, shell_argv[1:] + ['printf "%s\n" "%" 1'] |
|
|
|
CallNeomake 1, [maker] |
|
AssertEqual map(getloclist(0), 'v:val.text'), [ |
|
\ 'tests/fixtures/a filename with spaces', |
|
\ '1', |
|
\ 'tests/fixtures/a filename with spaces'] |
|
bwipe |
|
|
|
Execute (neomake#utils#MakerFromCommand appends args for file_mode (list)): |
|
let maker = neomake#utils#MakerFromCommand(['echo', '%', '1']) |
|
let jobinfo = {'file_mode': 0, 'bufnr': bufnr('%'), 'ft': ''} |
|
|
|
AssertEqual maker, { |
|
\ '__command_is_string': 0, |
|
\ '_get_argv': get(maker, '_get_argv'), |
|
\ '_get_fname_for_args': get(maker, '_get_fname_for_args'), |
|
\ 'args': ['%', '1'], |
|
\ 'exe': 'echo', |
|
\ 'remove_invalid_entries': 0} |
|
|
|
new |
|
edit tests/fixtures/a\ filename\ with\ spaces |
|
let fname = bufname('%') |
|
let jobinfo = NeomakeTestsFakeJobinfo() |
|
let jobinfo.maker = maker |
|
let bound_maker = neomake#GetMaker(maker) |
|
AssertEqual bound_maker.args, ['%', '1'] |
|
AssertEqual bound_maker.exe, 'echo' |
|
AssertEqual bound_maker.remove_invalid_entries, 0 |
|
|
|
let argv = bound_maker._get_argv(jobinfo) |
|
if type(argv) == type([]) |
|
AssertEqual argv, ['echo', fname, '1', fname] |
|
else |
|
AssertEqual argv, printf("echo '%s' 1 '%s'", fname, 'tests/fixtures/a filename with spaces') |
|
endif |
|
AssertEqual bound_maker.args, ['%', '1'] |
|
|
|
CallNeomake 0, [maker] |
|
AssertEqual getqflist()[0].text, 'tests/fixtures/a filename with spaces 1' |
|
bwipe |
|
|
|
Execute (neomake#utils#MakerFromCommand calls _get_fname_for_buffer once): |
|
let maker = neomake#utils#MakerFromCommand(['echo', '%', '1']) |
|
let maker.tempfile_enabled = 1 |
|
let maker.append_file = 1 |
|
let maker.uses_filename = 1 |
|
new |
|
file bufname |
|
setlocal modified |
|
CallNeomake 1, [maker] |
|
AssertNeomakeMessage '\v^Using tempfile for modified buffer: "(.*)".$' |
|
let tempfile_name = g:neomake_test_matchlist[1] |
|
AssertEqual len(filter(copy(g:neomake_test_messages), "v:val[1] =~ '^Using tempfile '")), 1 |
|
AssertEqual map(getloclist(0), 'v:val.text'), [ |
|
\ printf('bufname 1 %s', fnamemodify(tempfile_name, ':.'))] |
|
bwipe! |
|
|
|
Execute (neomake#utils#Stringify): |
|
AssertEqual neomake#utils#Stringify(1), 1 |
|
AssertEqual neomake#utils#Stringify('2'), '2' |
|
AssertEqual neomake#utils#Stringify([1, [2, 3]]), '[1, [2, 3]]' |
|
AssertEqual neomake#utils#Stringify([1, function('tr')]), "[1, function('tr')]" |
|
|
|
let obj = {'k': 'v'} |
|
function! obj.f(args) abort dict |
|
endfunction |
|
|
|
let fnr_base = substitute(string(obj.f), '\v.*''(\d+)''.*', '\1', '') |
|
AssertEqual neomake#utils#Stringify(obj), "{f: function('".fnr_base."'), k: v}" |
|
|
|
let base = {'base': 1} |
|
function! base.f2(arg) abort dict |
|
return a:arg |
|
endfunction |
|
|
|
let string_displays_partial = has('patch-7.4.1608') |
|
|
|
let obj = {} |
|
let obj.f2 = base.f2 |
|
AssertEqual obj.f2('called1'), 'called1' |
|
if string_displays_partial |
|
AssertEqual neomake#utils#Stringify(obj), "{f2: function('".(fnr_base + 1)."', {…})}" |
|
else |
|
AssertEqual neomake#utils#Stringify(obj), "{f2: function('".(fnr_base + 1)."')}" |
|
endif |
|
|
|
AssertEqual base.f2('called2'), 'called2' |
|
AssertEqual neomake#utils#Stringify(base), "{f2: function('".(fnr_base + 1)."'), base: 1}" |
|
|
|
let obj = copy(base) |
|
AssertEqual obj.f2, base.f2 |
|
let obj.base = 0 |
|
AssertEqual neomake#utils#Stringify(obj), "{f2: function('".(fnr_base + 1)."'), base: 0}" |
|
if string_displays_partial |
|
" Uses string() for 7.4.1689. |
|
AssertNotEqual string(obj.f2), string(base.f2) |
|
else |
|
AssertEqual obj.f2, base.f2 |
|
endif |
|
|
|
let obj.f2 = base.f2 |
|
if string_displays_partial |
|
AssertEqual neomake#utils#Stringify(obj.f2), "function('".(fnr_base + 1)."', ".string(obj).")" |
|
else |
|
AssertEqual neomake#utils#Stringify(obj.f2), "function('".(fnr_base + 1)."')" |
|
endif |
|
|
|
let obj = extend(copy(base), {}) |
|
AssertEqual obj.f2('called2'), 'called2' |
|
if string_displays_partial |
|
AssertEqual neomake#utils#Stringify(obj.f2), "function('".(fnr_base + 1)."', ".string(obj).")" |
|
else |
|
AssertEqual neomake#utils#Stringify(obj.f2), "function('".(fnr_base + 1)."')" |
|
endif |
|
AssertEqual neomake#utils#Stringify(obj), "{f2: function('".(fnr_base + 1)."'), base: 1}" |
|
|
|
Execute (neomake#utils#MakerFromCommand uses tempfile): |
|
let maker = neomake#utils#MakerFromCommand('echo') |
|
|
|
new |
|
edit tests/fixtures/a\ filename\ with\ spaces |
|
set modified |
|
let b:neomake_tempfile_enabled = 1 |
|
let jobinfo = NeomakeTestsFakeJobinfo() |
|
|
|
let bound_maker = neomake#GetMaker(maker) |
|
let make_info = values(neomake#GetStatus().make_info)[0] |
|
" For make_info.entries_list to be available. |
|
let make_info.entries_list = neomake#list#ListForMake(make_info) |
|
Assert !has_key(make_info, 'tempfiles') |
|
let shell_argv = split(&shell) + split(&shellcmdflag) |
|
AssertEqual bound_maker.args, shell_argv[1:] + ['echo'] |
|
AssertEqual bound_maker.exe, shell_argv[0] |
|
AssertEqual bound_maker.remove_invalid_entries, 0 |
|
|
|
call bound_maker._get_argv(jobinfo) |
|
let temp_file = fnamemodify(make_info.tempfiles[0], ':.') |
|
AssertNotEqual temp_file, fnameescape(temp_file) |
|
|
|
doautocmd neomake VimLeave |
|
Assert empty(glob(temp_file)), 'Temporary file was removed.' |
|
AssertNeomakeMessage printf('Removing temporary file: "%s".', make_info.tempfiles[0]) |
|
bwipe! |
|
|
|
Execute (neomake#utils#get_config_fts): |
|
function! s:F(ft) abort |
|
return neomake#utils#get_config_fts(a:ft) |
|
endfunction |
|
AssertEqual s:F('foo'), ['foo'] |
|
AssertEqual s:F('foo.bar'), ['foo_bar', 'foo', 'bar'] |
|
AssertEqual s:F('bar.foo'), ['bar_foo', 'bar', 'foo'] |
|
AssertEqual s:F('jsx.javascript'), ['jsx_javascript', 'jsx', 'javascript'] |
|
AssertEqual s:F('javascript.jsx'), ['javascript_jsx', 'javascript', 'jsx'] |
|
AssertEqual s:F('jsx'), ['jsx', 'javascript'] |
|
|
|
Execute (neomake#utils#fnamemodify handles fugitive buffer): |
|
NeomakeTestsLoadPlugin 'vim-fugitive' |
|
new |
|
edit autoload/neomake/debug.vim |
|
let bufname = bufname('%') |
|
let bufname_abs = fnamemodify(bufname, ':p') |
|
|
|
Gedit |
|
AssertNotEqual bufname, bufname('%') |
|
Assert bufname('%') =~# '^fugitive://' |
|
|
|
AssertEqual neomake#utils#fnamemodify(bufnr('%'), ''), bufname |
|
AssertEqual neomake#utils#fnamemodify(bufnr('%'), ':p'), bufname_abs |
|
AssertEqual neomake#utils#fnamemodify(bufnr('%'), ':p:h'), fnamemodify(bufname_abs, ':h') |
|
|
|
" ExpandArgs handles fugitive buffers also. |
|
let jobinfo = {'bufnr': bufnr('%')} |
|
AssertEqual neomake#utils#ExpandArgs(['%'], jobinfo), [bufname] |
|
AssertEqual neomake#utils#ExpandArgs(['%:e'], jobinfo), ['vim'] |
|
" NOTE: uses absolute path, although bufname is relative. |
|
AssertEqual neomake#utils#ExpandArgs(['%<'], jobinfo), [fnamemodify(bufname, ':p:r')] |
|
|
|
exe 'lcd '.fnamemodify(tempname(), ':h') |
|
AssertEqual neomake#utils#fnamemodify(bufnr('%'), ''), bufname_abs |
|
AssertEqual neomake#utils#fnamemodify(bufnr('%'), ':p'), bufname_abs |
|
AssertEqual neomake#utils#fnamemodify(bufnr('%'), ':p:h'), fnamemodify(bufname_abs, ':h') |
|
|
|
bwipe |
|
bwipe autoload/neomake/debug.vim |
|
if exists('*VimFtpluginUndo') |
|
delfunction VimFtpluginUndo |
|
endif |
|
|
|
Execute (neomake#utils#fnamemodify handles empty bufname): |
|
new |
|
AssertEqual bufname('%'), '' |
|
AssertEqual neomake#utils#fnamemodify(bufnr('%'), ''), '' |
|
AssertEqual neomake#utils#fnamemodify(bufnr('%'), ':p'), '' |
|
bwipe |
|
|
|
Execute (neomake#utils#FindGlobFile): |
|
let tempdir = tempname() |
|
let slash = neomake#utils#Slash() |
|
let subdir = tempdir . slash . 'sub' |
|
call mkdir(subdir, 'p', 0700) |
|
|
|
let tempfile = tempdir.slash.'temp-file' |
|
call writefile([], tempfile) |
|
let file_in_tempdir = tempdir.slash.'common-file' |
|
call writefile([], file_in_tempdir) |
|
let subfile = subdir.slash.'sub-file' |
|
call writefile([], subfile) |
|
let file_in_subdir = subdir.slash.'common-file' |
|
call writefile([], file_in_subdir) |
|
let anotherfile_in_subdir = subdir.slash.'common-file-2' |
|
call writefile([], anotherfile_in_subdir) |
|
|
|
new |
|
exe 'lcd' subdir |
|
AssertEqual neomake#utils#FindGlobFile('doesnotexist'), '' |
|
AssertEqual neomake#utils#FindGlobFile('sub-file'), subfile |
|
AssertEqual neomake#utils#FindGlobFile('sub-file', tempdir), '' |
|
AssertEqual neomake#utils#FindGlobFile('common-file'), file_in_subdir |
|
AssertEqual neomake#utils#FindGlobFile('common-file', tempdir), file_in_tempdir |
|
|
|
exe 'lcd' tempdir |
|
AssertEqual neomake#utils#FindGlobFile('sub-file'), '' |
|
AssertEqual neomake#utils#FindGlobFile('sub-file', subdir), subfile |
|
AssertEqual neomake#utils#FindGlobFile('sub-file', tempdir), '' |
|
AssertEqual neomake#utils#FindGlobFile('sub-file', tempname()), '' |
|
AssertEqual neomake#utils#FindGlobFile('common-file'), file_in_tempdir |
|
AssertEqual neomake#utils#FindGlobFile('common-file'), file_in_tempdir |
|
AssertEqual neomake#utils#FindGlobFile('common-file', subdir), file_in_subdir |
|
|
|
" Only the first found file gets returned. |
|
AssertEqual neomake#utils#FindGlobFile('common-file{,-2}', subdir), file_in_subdir |
|
AssertEqual neomake#utils#FindGlobFile('common-file{-2,}', subdir), anotherfile_in_subdir |
|
bwipe |
|
|
|
Execute (neomake#utils#shellescape): |
|
AssertEqual neomake#utils#shellescape('foo'), 'foo' |
|
AssertEqual neomake#utils#shellescape('foo-bar'), 'foo-bar' |
|
AssertEqual neomake#utils#shellescape('foo_bar'), 'foo_bar' |
|
AssertEqual neomake#utils#shellescape('foo bar'), "'foo bar'" |
|
AssertEqual neomake#utils#shellescape('foo bar "baz"'), "'foo bar \"baz\"'" |
|
AssertEqual neomake#utils#shellescape('--foo=bar'), '--foo=bar' |
|
|
|
Save &shell |
|
let &shell = 'cmd.exe' |
|
AssertEqual neomake#utils#shellescape('foo'), 'foo' |
|
AssertEqual neomake#utils#shellescape('foo-bar'), 'foo-bar' |
|
AssertEqual neomake#utils#shellescape('foo_bar'), 'foo_bar' |
|
AssertEqual neomake#utils#shellescape('foo bar'), '"foo bar"' |
|
AssertEqual neomake#utils#shellescape('foo bar "baz"'), '"foo bar ""baz"""' |
|
|
|
AssertEqual neomake#utils#shellescape('"foo"'), '"""foo"""' |
|
AssertEqual neomake#utils#shellescape('"foo bar"'), '"""foo bar"""' |
|
AssertEqual neomake#utils#shellescape('-c "foo bar"'), '"-c ""foo bar"""' |
|
|
|
Execute (neomake#utils#fix_self_ref): |
|
AssertEqual neomake#utils#fix_self_ref(''), '' |
|
|
|
let obj = {'foo': 1, 'bar': {}} |
|
AssertEqual neomake#utils#fix_self_ref(obj), { |
|
\ 'foo': 1, |
|
\ 'bar': {}} |
|
let fixed = neomake#utils#fix_self_ref(obj) |
|
Assert fixed is obj, 'does not copy unnecessarily' |
|
|
|
let obj.bar.self_ref = obj |
|
let exception = '' |
|
try |
|
let str_obj = string(obj) |
|
catch /^Vim(let):E724:/ |
|
let exception = v:exception |
|
endtry |
|
if has('nvim') |
|
AssertEqual exception, 'Vim(let):E724: unable to correctly dump variable with self-referencing container' |
|
elseif has('patch-7.4.1644') |
|
AssertEqual str_obj, "{'foo': 1, 'bar': {'self_ref': {...}}}" |
|
else |
|
AssertEqual exception, 'Vim(let):E724: variable nested too deep for displaying' |
|
endif |
|
let fixed = neomake#utils#fix_self_ref(obj) |
|
call string(fixed) |
|
AssertEqual fixed, { |
|
\ 'foo': 1, |
|
\ 'bar': {'self_ref': '<self-ref-1: bar>'}} |
|
|
|
Assert obj.bar.self_ref is obj, 'self_ref is obj' |
|
|
|
let obj.baz = {} |
|
let obj.baz.self_ref_obj = obj |
|
let obj.baz.self_ref_baz = obj.baz |
|
let fixed = neomake#utils#fix_self_ref(obj) |
|
AssertEqual fixed, { |
|
\ 'foo': 1, |
|
\ 'bar': {'self_ref': '<self-ref-1: bar>'}, |
|
\ 'baz': { |
|
\ 'self_ref_obj': '<self-ref-1: baz>', |
|
\ 'self_ref_baz': { |
|
\ 'self_ref_obj': '<self-ref-1: baz>', |
|
\ 'self_ref_baz': '<self-ref-2: self_ref_baz>' |
|
\ } |
|
\ }} |
|
|
|
Execute (neomake#utils#fix_self_ref with obj.func = obj.func): |
|
let string_displays_partial = has('patch-7.4.1608') |
|
let maker = {} |
|
function maker.args() |
|
endfunction |
|
let str_func = string(get(maker, 'args')) |
|
let maker.args = maker.args |
|
let repr = neomake#utils#fix_self_ref(maker) |
|
AssertEqual keys(repr), ['args'] |
|
|
|
if string_displays_partial |
|
if has('nvim') |
|
AssertEqual string(repr), "{'args': '<unrepresentable object, type=2>'}" |
|
AssertEqual neomake#utils#fix_self_ref(maker.args), '<unrepresentable object, type=2>' |
|
AssertEqual neomake#utils#fix_self_ref(get(maker, 'args')), '<unrepresentable object, type=2>' |
|
else |
|
let str_number = matchstr(str_func, '\d\+') |
|
AssertEqual string(repr), printf( |
|
\ "{'args': function('%d', {...})}", |
|
\ str_number) |
|
AssertEqual neomake#utils#fix_self_ref(maker.args), maker.args |
|
AssertEqual neomake#utils#fix_self_ref(get(maker, 'args')), maker.args |
|
endif |
|
else |
|
AssertEqual string(repr), printf("{'args': %s}", str_func) |
|
AssertEqual neomake#utils#fix_self_ref(maker.args), maker.args |
|
endif |
|
|
|
|
|
Execute (neomake#utils#fix_self_ref: handles lists): |
|
let maker = {} |
|
function maker.args() |
|
endfunction |
|
let maker.args = maker.args |
|
let repr = neomake#utils#fix_self_ref([maker]) |
|
AssertEqual keys(repr[0]), ['args'] |
|
call string(repr) |
|
|
|
Execute (neomake#utils#fix_self_ref: uses get(obj, k)): |
|
let make_info = {} |
|
let entries_list = {} |
|
let entries_list.make_info = make_info |
|
let make_info.entries_list = entries_list |
|
AssertEqual neomake#utils#fix_self_ref(make_info), { |
|
\ 'entries_list': {'make_info': '<self-ref-1: entries_list>'}} |
|
|
|
" This used to trigger "unrepresentable object" in Neovim. |
|
" (https://github.com/neovim/neovim/issues/7432) |
|
function entries_list.func() abort dict |
|
endfunction |
|
AssertEqual string(neomake#utils#fix_self_ref(make_info)), |
|
\ printf("{'entries_list': {'func': %s, 'make_info': '<self-ref-1: entries_list>'}}", |
|
\ string(get(entries_list, 'func'))) |
|
|
|
Execute (neomake#utils#Stringify: uses neomake#utils#fix_self_ref): |
|
let maker = {} |
|
function maker.args() |
|
endfunction |
|
let maker.args = maker.args |
|
let repr = neomake#utils#Stringify(maker) |
|
Assert repr =~# '\V{args: \.\*}' |
|
|
|
Execute (neomake#utils#write_tempfile): |
|
Save &endofline, &binary |
|
let vim_temp = tempname() |
|
let neomake_temp = tempname() |
|
|
|
if !exists('+fixeol') |
|
NeomakeTestsSkip 'Skipping +fixeol variants' |
|
let variants = [ |
|
\ 'endofline binary', |
|
\ 'endofline nobinary', |
|
\ 'noendofline binary', |
|
\ 'noendofline nobinary', |
|
\ ] |
|
else |
|
Save &fixeol |
|
let variants = [ |
|
\ 'fixeol endofline binary', |
|
\ 'fixeol endofline nobinary', |
|
\ 'fixeol noendofline binary', |
|
\ 'fixeol noendofline nobinary', |
|
\ 'nofixeol endofline binary', |
|
\ 'nofixeol endofline nobinary', |
|
\ 'nofixeol noendofline binary', |
|
\ 'nofixeol noendofline nobinary', |
|
\ ] |
|
endif |
|
|
|
for variant in variants |
|
new |
|
let bufnr = bufnr('%') |
|
exe 'set' variant |
|
|
|
exe 'w!' vim_temp |
|
new |
|
call neomake#utils#write_tempfile(bufnr, neomake_temp) |
|
AssertEqual readfile(vim_temp, 'b'), readfile(neomake_temp, 'b') |
|
|
|
b# |
|
normal! ifoo |
|
exe 'w!' vim_temp |
|
b# |
|
call neomake#utils#write_tempfile(bufnr, neomake_temp) |
|
AssertEqual readfile(vim_temp, 'b'), readfile(neomake_temp, 'b') |
|
bwipe! |
|
bwipe |
|
endfor |
|
|
|
Execute (neomake#utils#highlight_is_defined): |
|
AssertEqual neomake#utils#highlight_is_defined('Error'), 1 |
|
AssertEqual neomake#utils#highlight_is_defined('NeomakeCustomHilight'), 0 |
|
hi clear NeomakeCustomHilight |
|
AssertEqual neomake#utils#highlight_is_defined('NeomakeCustomHilight'), 0 |
|
hi link NeomakeCustomHilight Error |
|
AssertEqual neomake#utils#highlight_is_defined('NeomakeCustomHilight'), 1 |
|
hi link NeomakeCustomHilight NONE |
|
AssertEqual neomake#utils#highlight_is_defined('NeomakeCustomHilight'), 0 |
|
|
|
Execute (NeomakeTestsGetVimMessages): |
|
call NeomakeTestsSetVimMessagesMarker() |
|
AssertEqual NeomakeTestsGetVimMessages(), [] |
|
AssertEqual NeomakeTestsGetVimMessages(), [] |
|
echom 1 |
|
AssertEqual NeomakeTestsGetVimMessages(), ['1'] |
|
echom 2 |
|
echom 3 |
|
AssertEqual NeomakeTestsGetVimMessages(), ['2', '3'] |
|
|
|
Execute (neomake#utils#get_buf_line_count): |
|
new |
|
let bufnr = bufnr('%') |
|
AssertEqual neomake#utils#get_buf_line_count(bufnr), 1 |
|
|
|
norm! 7o |
|
AssertEqual line('$'), 8 |
|
AssertEqual neomake#utils#get_buf_line_count(bufnr), 8 |
|
|
|
new |
|
AssertEqual neomake#utils#get_buf_line_count(bufnr), 8 |
|
|
|
let non_existing_buffer = bufnr+100 |
|
Assert !bufexists(non_existing_buffer) |
|
AssertEqual neomake#utils#get_buf_line_count(non_existing_buffer), 0 |
|
bwipe |
|
bwipe! |
|
|
|
Execute (neomake#utils#get_buf_line_count: unloaded buffer): |
|
new |
|
|
|
" Create an unlisted buffer. |
|
call setloclist(0, [{'filename': 'unlisted_buffer'}]) |
|
let unlisted_bufnr = bufnr('^unlisted_buffer') |
|
Assert !buflisted(unlisted_bufnr) |
|
|
|
AssertEqual neomake#utils#get_buf_line_count(unlisted_bufnr), 0 |
|
exe 'b '.unlisted_bufnr |
|
AssertEqual neomake#utils#get_buf_line_count(unlisted_bufnr), 1 |
|
bp |
|
bwipe |
|
exe unlisted_bufnr.'bwipe' |
|
|
|
Execute (neomake#utils#temp_cd): |
|
let cwd = getcwd() |
|
try |
|
AssertEqual neomake#utils#temp_cd('.'), ['', ''] |
|
AssertEqual neomake#utils#temp_cd(cwd), ['', ''] |
|
|
|
" If cur_wd gets passed in the caller is responsible if cd'ing should not get done. |
|
AssertEqual neomake#utils#temp_cd(cwd, cwd), ['', 'cd '.fnameescape(cwd)] |
|
|
|
let tempdir = tempname() |
|
AssertEqual neomake#utils#temp_cd(cwd, tempdir), ['', 'cd '.fnameescape(tempdir)] |
|
let [cd_error, cd_back_cmd] = neomake#utils#temp_cd(tempdir, cwd) |
|
Assert !empty(cd_error) |
|
AssertEqual cd_back_cmd, '' |
|
|
|
call mkdir(tempdir) |
|
AssertEqual neomake#utils#temp_cd(cwd, tempdir), ['', 'cd '.fnameescape(tempdir)] |
|
AssertEqual neomake#utils#temp_cd(tempdir, cwd), ['', 'cd '.fnameescape(cwd)] |
|
finally |
|
exe 'cd '.fnameescape(cwd) |
|
endtry |
|
|
|
Execute (neomake#utils#buf_get_lines): |
|
new |
|
let b = bufnr('%') |
|
AssertEqual neomake#utils#buf_get_lines(b, 1, 1), [] |
|
AssertEqual neomake#utils#buf_get_lines(b, 1, 2), [''] |
|
|
|
call setline(1, '1') |
|
AssertEqual getline(1, '$'), ['1'] |
|
AssertEqual neomake#utils#buf_get_lines(b, 1, 2), ['1'] |
|
|
|
" end > lines |
|
let threw = 0 |
|
try |
|
call neomake#utils#buf_get_lines(b, 1, 3) |
|
catch |
|
let threw = 1 |
|
if has('nvim') |
|
Assert v:exception =~# '\Vneomake#utils#buf_get_lines: \.\*Index out of bounds', v:exception |
|
else |
|
AssertEqual v:exception, 'neomake#utils#buf_get_lines: end is higher than number of lines' |
|
endif |
|
endtry |
|
AssertEqual threw, 1 |
|
|
|
" start < 1 |
|
let threw = 0 |
|
try |
|
call neomake#utils#buf_get_lines(b, 0, 1) |
|
catch |
|
let threw = 1 |
|
AssertEqual v:exception, 'neomake#utils#buf_get_lines: start is lower than 1' |
|
endtry |
|
AssertEqual threw, 1 |
|
|
|
call setline(2, '2') |
|
AssertEqual neomake#utils#buf_get_lines(b, 1, 2), ['1'] |
|
AssertEqual neomake#utils#buf_get_lines(b, 1, 3), ['1', '2'] |
|
|
|
AssertEqual getline(1, '$'), ['1', '2'] |
|
bwipe! |
|
|
|
Execute (neomake#utils#buf_set_lines): |
|
new |
|
let b = bufnr('%') |
|
AssertEqual neomake#utils#buf_set_lines(b, 1, 1, ['1']), '' |
|
AssertEqual getline(1, '$'), ['1', ''] |
|
|
|
AssertEqual neomake#utils#buf_set_lines(b, 1, 3, ['1', '2']), '' |
|
AssertEqual getline(1, '$'), ['1', '2'] |
|
|
|
" end > lines |
|
let error = neomake#utils#buf_set_lines(b, 1, 4, []) |
|
if has('nvim') |
|
Assert error =~# 'neomake#utils#buf_set_lines: .*Index out of bounds', error |
|
else |
|
AssertEqual error, 'neomake#utils#buf_set_lines: end is higher than number of lines' |
|
endif |
|
|
|
" start < 1 |
|
let error = neomake#utils#buf_set_lines(b, 0, 1, []) |
|
AssertEqual error, 'neomake#utils#buf_set_lines: start is lower than 1' |
|
|
|
AssertEqual neomake#utils#buf_set_lines(b, 2, 3, ['2', '3']), '' |
|
AssertEqual getline(1, '$'), ['1', '2', '3'] |
|
|
|
AssertEqual neomake#utils#buf_set_lines(b, 2, 4, []), '' |
|
AssertEqual getline(1, '$'), ['1'] |
|
bwipe! |
|
|
|
Execute (Different buffer with buf_get_lines/buf_set_lines): |
|
" Neovim can handle different buffers. |
|
new |
|
let b = bufnr('%') |
|
new |
|
if exists('*nvim_buf_get_lines') |
|
AssertEqual neomake#utils#buf_set_lines(b, 1, 1, ['1', '2']), '' |
|
AssertEqual neomake#utils#buf_get_lines(b, 1, 3), ['1', '2'] |
|
else |
|
let threw = 0 |
|
try |
|
call neomake#utils#buf_get_lines(b, 1, 3) |
|
catch |
|
let threw = 1 |
|
AssertEqual v:exception, 'Neomake: neomake#utils#buf_get_lines: used for non-current buffer' |
|
endtry |
|
Assert threw |
|
|
|
AssertEqual neomake#utils#buf_set_lines(b, 1, 1, ['1', '2']), 'neomake#utils#buf_set_lines: used for non-current buffer' |
|
endif |
|
bwipe! |
|
bwipe! |
|
|
|
Execute (neomake#utils#shorten_list_for_log): |
|
AssertEqual neomake#utils#shorten_list_for_log([], 1), [] |
|
AssertEqual neomake#utils#shorten_list_for_log([1, 2, 3], 1), [1, '... (3 total)']
|
|
|