Patch 8.2.1660

[Bram Moolenaar]

Patch 8.2.1660
Problem: Assert functions require passing expected result as the first
argument, which isn't obvious.
Solution: Use a method, as in "runtest()->assert_equal(expected)".
Files: src/testdir/test_vim9_func.vim


*** ../vim-8.2.1659/src/testdir/test_vim9_func.vim 2020-09-10 22:27:57.805094402 +0200
--- src/testdir/test_vim9_func.vim 2020-09-11 18:58:32.217949316 +0200
***************
*** 10,16 ****
def SomeFunc(): string
return 'yes'
enddef
! call assert_equal('yes', SomeFunc())
endfunc

def ReturnString(): string
--- 10,16 ----
def SomeFunc(): string
return 'yes'
enddef
! call SomeFunc()->assert_equal('yes')
endfunc

def ReturnString(): string
***************
*** 28,35 ****
enddef

def Test_return_something()
! assert_equal('string', ReturnString())
! assert_equal(123, ReturnNumber())
assert_fails('ReturnGlobal()', 'E1029: Expected number but got string', '', 1, 'ReturnGlobal')
enddef

--- 28,35 ----
enddef

def Test_return_something()
! ReturnString()->assert_equal('string')
! ReturnNumber()->assert_equal(123)
assert_fails('ReturnGlobal()', 'E1029: Expected number but got string', '', 1, 'ReturnGlobal')
enddef

***************
*** 69,75 ****

def Test_return_nothing()
ReturnNothing()
! assert_equal(1, s:nothing)
enddef

func Increment()
--- 69,75 ----

def Test_return_nothing()
ReturnNothing()
! s:nothing->assert_equal(1)
enddef

func Increment()
***************
*** 82,89 ****
Increment()
Increment()
# works with and without :call
! assert_equal(4, g:counter)
! call assert_equal(4, g:counter)
unlet g:counter
enddef

--- 82,89 ----
Increment()
Increment()
# works with and without :call
! g:counter->assert_equal(4)
! eval g:counter->assert_equal(4)
unlet g:counter
enddef

***************
*** 96,104 ****
enddef

def Test_call_varargs()
! assert_equal('one', MyVarargs('one'))
! assert_equal('one,two', MyVarargs('one', 'two'))
! assert_equal('one,two,three', MyVarargs('one', 'two', 'three'))
enddef

def MyDefaultArgs(name = 'string'): string
--- 96,104 ----
enddef

def Test_call_varargs()
! MyVarargs('one')->assert_equal('one')
! MyVarargs('one', 'two')->assert_equal('one,two')
! MyVarargs('one', 'two', 'three')->assert_equal('one,two,three')
enddef

def MyDefaultArgs(name = 'string'): string
***************
*** 110,122 ****
enddef

def Test_call_default_args()
! assert_equal('string', MyDefaultArgs())
! assert_equal('one', MyDefaultArgs('one'))
assert_fails('MyDefaultArgs("one", "two")', 'E118:', '', 3, 'Test_call_default_args')

! assert_equal('test', MyDefaultSecond('test'))
! assert_equal('test', MyDefaultSecond('test', true))
! assert_equal('none', MyDefaultSecond('test', false))

CheckScriptFailure(['def Func(arg: number = asdf)', 'enddef', 'defcompile'], 'E1001:')
CheckScriptFailure(['def Func(arg: number = "text")', 'enddef', 'defcompile'], 'E1013: argument 1: type mismatch, expected number but got string')
--- 110,122 ----
enddef

def Test_call_default_args()
! MyDefaultArgs()->assert_equal('string')
! MyDefaultArgs('one')->assert_equal('one')
assert_fails('MyDefaultArgs("one", "two")', 'E118:', '', 3, 'Test_call_default_args')

! MyDefaultSecond('test')->assert_equal('test')
! MyDefaultSecond('test', true)->assert_equal('test')
! MyDefaultSecond('test', false)->assert_equal('none')

CheckScriptFailure(['def Func(arg: number = asdf)', 'enddef', 'defcompile'], 'E1001:')
CheckScriptFailure(['def Func(arg: number = "text")', 'enddef', 'defcompile'], 'E1013: argument 1: type mismatch, expected number but got string')
***************
*** 126,132 ****
def Nested(arg: string): string
return 'nested ' .. arg
enddef
! assert_equal('nested function', Nested('function'))

CheckDefFailure(['def Nested()', 'enddef', 'Nested(66)'], 'E118:')
CheckDefFailure(['def Nested(arg: string)', 'enddef', 'Nested()'], 'E119:')
--- 126,132 ----
def Nested(arg: string): string
return 'nested ' .. arg
enddef
! Nested('function')->assert_equal('nested function')

CheckDefFailure(['def Nested()', 'enddef', 'Nested(66)'], 'E118:')
CheckDefFailure(['def Nested(arg: string)', 'enddef', 'Nested()'], 'E119:')
***************
*** 154,161 ****
enddef

func Test_call_default_args_from_func()
! call assert_equal('string', MyDefaultArgs())
! call assert_equal('one', MyDefaultArgs('one'))
call assert_fails('call MyDefaultArgs("one", "two")', 'E118:', '', 3, 'Test_call_default_args_from_func')
endfunc

--- 154,161 ----
enddef

func Test_call_default_args_from_func()
! call MyDefaultArgs()->assert_equal('string')
! call MyDefaultArgs('one')->assert_equal('one')
call assert_fails('call MyDefaultArgs("one", "two")', 'E118:', '', 3, 'Test_call_default_args_from_func')
endfunc

***************
*** 169,181 ****
enddef
defcompile
Outer()
! assert_equal('inner', g:Inner())
delfunc g:Inner
Outer()
! assert_equal('inner', g:Inner())
delfunc g:Inner
Outer()
! assert_equal('inner', g:Inner())
delfunc g:Inner
END
CheckScriptSuccess(lines)
--- 169,181 ----
enddef
defcompile
Outer()
! g:Inner()->assert_equal('inner')
delfunc g:Inner
Outer()
! g:Inner()->assert_equal('inner')
delfunc g:Inner
Outer()
! g:Inner()->assert_equal('inner')
delfunc g:Inner
END
CheckScriptSuccess(lines)
***************
*** 217,224 ****
def Func(): string
return 'local'
enddef
! assert_equal('global', g:Func())
! assert_equal('local', Func())
END
CheckScriptSuccess(lines)

--- 217,224 ----
def Func(): string
return 'local'
enddef
! g:Func()->assert_equal('global')
! Func()->assert_equal('local')
END
CheckScriptSuccess(lines)

***************
*** 263,271 ****

def Test_call_def_varargs()
assert_fails('MyDefVarargs()', 'E119:', '', 1, 'Test_call_def_varargs')
! assert_equal('one,foo', MyDefVarargs('one'))
! assert_equal('one,two', MyDefVarargs('one', 'two'))
! assert_equal('one,two,three', MyDefVarargs('one', 'two', 'three'))
CheckDefFailure(['MyDefVarargs("one", 22)'],
'E1013: argument 2: type mismatch, expected string but got number')
CheckDefFailure(['MyDefVarargs("one", "two", 123)'],
--- 263,271 ----

def Test_call_def_varargs()
assert_fails('MyDefVarargs()', 'E119:', '', 1, 'Test_call_def_varargs')
! MyDefVarargs('one')->assert_equal('one,foo')
! MyDefVarargs('one', 'two')->assert_equal('one,two')
! MyDefVarargs('one', 'two', 'three')->assert_equal('one,two,three')
CheckDefFailure(['MyDefVarargs("one", 22)'],
'E1013: argument 2: type mismatch, expected string but got number')
CheckDefFailure(['MyDefVarargs("one", "two", 123)'],
***************
*** 320,326 ****
def Test_call_call()
let l = [3, 2, 1]
call('reverse', [l])
! assert_equal([1, 2, 3], l)
enddef

let s:value = ''
--- 320,326 ----
def Test_call_call()
let l = [3, 2, 1]
call('reverse', [l])
! l->assert_equal([1, 2, 3])
enddef

let s:value = ''
***************
*** 341,364 ****
let RefDefArg: func(?string)
RefDefArg = FuncOneDefArg
RefDefArg()
! assert_equal('text', s:value)
RefDefArg('some')
! assert_equal('some', s:value)

let RefDef2Arg: func(?number, ?string): string
RefDef2Arg = FuncTwoDefArg
! assert_equal('123text', RefDef2Arg())
! assert_equal('99text', RefDef2Arg(99))
! assert_equal('77some', RefDef2Arg(77, 'some'))

CheckDefFailure(['let RefWrong: func(string?)'], 'E1010:')
CheckDefFailure(['let RefWrong: func(?string, string)'], 'E1007:')

let RefVarargs: func(...list<string>): string
RefVarargs = FuncVarargs
! assert_equal('', RefVarargs())
! assert_equal('one', RefVarargs('one'))
! assert_equal('one,two', RefVarargs('one', 'two'))

CheckDefFailure(['let RefWrong: func(...list<string>, string)'], 'E110:')
CheckDefFailure(['let RefWrong: func(...list<string>, ?string)'], 'E110:')
--- 341,364 ----
let RefDefArg: func(?string)
RefDefArg = FuncOneDefArg
RefDefArg()
! s:value->assert_equal('text')
RefDefArg('some')
! s:value->assert_equal('some')

let RefDef2Arg: func(?number, ?string): string
RefDef2Arg = FuncTwoDefArg
! RefDef2Arg()->assert_equal('123text')
! RefDef2Arg(99)->assert_equal('99text')
! RefDef2Arg(77, 'some')->assert_equal('77some')

CheckDefFailure(['let RefWrong: func(string?)'], 'E1010:')
CheckDefFailure(['let RefWrong: func(?string, string)'], 'E1007:')

let RefVarargs: func(...list<string>): string
RefVarargs = FuncVarargs
! RefVarargs()->assert_equal('')
! RefVarargs('one')->assert_equal('one')
! RefVarargs('one', 'two')->assert_equal('one,two')

CheckDefFailure(['let RefWrong: func(...list<string>, string)'], 'E110:')
CheckDefFailure(['let RefWrong: func(...list<string>, ?string)'], 'E110:')
***************
*** 370,378 ****
enddef

def Test_call_varargs_only()
! assert_equal('', MyVarargsOnly())
! assert_equal('one', MyVarargsOnly('one'))
! assert_equal('one,two', MyVarargsOnly('one', 'two'))
CheckDefFailure(['MyVarargsOnly(1)'], 'E1013: argument 1: type mismatch, expected string but got number')
CheckDefFailure(['MyVarargsOnly("one", 2)'], 'E1013: argument 2: type mismatch, expected string but got number')
enddef
--- 370,378 ----
enddef

def Test_call_varargs_only()
! MyVarargsOnly()->assert_equal('')
! MyVarargsOnly('one')->assert_equal('one')
! MyVarargsOnly('one', 'two')->assert_equal('one,two')
CheckDefFailure(['MyVarargsOnly(1)'], 'E1013: argument 1: type mismatch, expected string but got number')
CheckDefFailure(['MyVarargsOnly("one", 2)'], 'E1013: argument 2: type mismatch, expected string but got number')
enddef
***************
*** 395,410 ****
# works for dict and list
let d: dict<string> = {}
DictArg(d)
! assert_equal('value', d['key'])
let l: list<string> = []
ListArg(l)
! assert_equal('value', l[0])

CheckScriptFailure(['def Func(arg: number)', 'arg = 3', 'enddef', 'defcompile'], 'E1090:')
enddef

def Test_call_func_defined_later()
! assert_equal('one', g:DefinedLater('one'))
assert_fails('NotDefined("one")', 'E117:', '', 2, 'Test_call_func_defined_later')
enddef

--- 395,410 ----
# works for dict and list
let d: dict<string> = {}
DictArg(d)
! d['key']->assert_equal('value')
let l: list<string> = []
ListArg(l)
! l[0]->assert_equal('value')

CheckScriptFailure(['def Func(arg: number)', 'arg = 3', 'enddef', 'defcompile'], 'E1090:')
enddef

def Test_call_func_defined_later()
! g:DefinedLater('one')->assert_equal('one')
assert_fails('NotDefined("one")', 'E117:', '', 2, 'Test_call_func_defined_later')
enddef

***************
*** 413,419 ****
endfunc

def Test_call_funcref()
! assert_equal(3, g:SomeFunc('abc'))
assert_fails('NotAFunc()', 'E117:', '', 2, 'Test_call_funcref') # comment after call
assert_fails('g:NotAFunc()', 'E117:', '', 3, 'Test_call_funcref')

--- 413,419 ----
endfunc

def Test_call_funcref()
! g:SomeFunc('abc')->assert_equal(3)
assert_fails('NotAFunc()', 'E117:', '', 2, 'Test_call_funcref') # comment after call
assert_fails('g:NotAFunc()', 'E117:', '', 3, 'Test_call_funcref')

***************
*** 423,429 ****
return 123
enddef
let Funcref: func: number = function('RetNumber')
! assert_equal(123, Funcref())
END
CheckScriptSuccess(lines)

--- 423,429 ----
return 123
enddef
let Funcref: func: number = function('RetNumber')
! Funcref()->assert_equal(123)
END
CheckScriptSuccess(lines)

***************
*** 436,442 ****
return F()
enddef
let Funcref = function('RetNumber')
! assert_equal(123, Bar(Funcref))
END
CheckScriptSuccess(lines)

--- 436,442 ----
return F()
enddef
let Funcref = function('RetNumber')
! Bar(Funcref)->assert_equal(123)
END
CheckScriptSuccess(lines)

***************
*** 466,474 ****
enddef
let Funcref: func(?number) = function('EchoNr')
Funcref()
! assert_equal(34, g:echo)
Funcref(123)
! assert_equal(123, g:echo)
END
CheckScriptSuccess(lines)

--- 466,474 ----
enddef
let Funcref: func(?number) = function('EchoNr')
Funcref()
! g:echo->assert_equal(34)
Funcref(123)
! g:echo->assert_equal(123)
END
CheckScriptSuccess(lines)

***************
*** 479,487 ****
enddef
let Funcref: func(...list<number>) = function('EchoList')
Funcref()
! assert_equal([], g:echo)
Funcref(1, 2, 3)
! assert_equal([1, 2, 3], g:echo)
END
CheckScriptSuccess(lines)

--- 479,487 ----
enddef
let Funcref: func(...list<number>) = function('EchoList')
Funcref()
! g:echo->assert_equal([])
Funcref(1, 2, 3)
! g:echo->assert_equal([1, 2, 3])
END
CheckScriptSuccess(lines)

***************
*** 493,509 ****
return nr
enddef
let Funcref: func(number, ?number, ...list<number>): number = function('OptAndVar')
! assert_equal(10, Funcref(10))
! assert_equal(12, g:optarg)
! assert_equal([], g:listarg)
!
! assert_equal(11, Funcref(11, 22))
! assert_equal(22, g:optarg)
! assert_equal([], g:listarg)
!
! assert_equal(17, Funcref(17, 18, 1, 2, 3))
! assert_equal(18, g:optarg)
! assert_equal([1, 2, 3], g:listarg)
END
CheckScriptSuccess(lines)
enddef
--- 493,509 ----
return nr
enddef
let Funcref: func(number, ?number, ...list<number>): number = function('OptAndVar')
! Funcref(10)->assert_equal(10)
! g:optarg->assert_equal(12)
! g:listarg->assert_equal([])
!
! Funcref(11, 22)->assert_equal(11)
! g:optarg->assert_equal(22)
! g:listarg->assert_equal([])
!
! Funcref(17, 18, 1, 2, 3)->assert_equal(17)
! g:optarg->assert_equal(18)
! g:listarg->assert_equal([1, 2, 3])
END
CheckScriptSuccess(lines)
enddef
***************
*** 604,671 ****
var = arg
enddef
MyFunc('foobar')
! assert_equal('foobar', var)

let str = 'barfoo'
str->MyFunc()
! assert_equal('barfoo', var)

g:value = 'value'
g:value->MyFunc()
! assert_equal('value', var)

let listvar = []
def ListFunc(arg: list<number>)
listvar = arg
enddef
[1, 2, 3]->ListFunc()
! assert_equal([1, 2, 3], listvar)

let dictvar = {}
def DictFunc(arg: dict<number>)
dictvar = arg
enddef
{'a': 1, 'b': 2}->DictFunc()
! assert_equal(#{a: 1, b: 2}, dictvar)
def CompiledDict()
{'a': 3, 'b': 4}->DictFunc()
enddef
CompiledDict()
! assert_equal(#{a: 3, b: 4}, dictvar)

#{a: 3, b: 4}->DictFunc()
! assert_equal(#{a: 3, b: 4}, dictvar)

('text')->MyFunc()
! assert_equal('text', var)
("some")->MyFunc()
! assert_equal('some', var)

# line starting with single quote is not a mark
# line starting with double quote can be a method call
'asdfasdf'->MyFunc()
! assert_equal('asdfasdf', var)
"xyz"->MyFunc()
! assert_equal('xyz', var)

def UseString()
'xyork'->MyFunc()
enddef
UseString()
! assert_equal('xyork', var)

def UseString2()
"knife"->MyFunc()
enddef
UseString2()
! assert_equal('knife', var)

# prepending a colon makes it a mark
new
setline(1, ['aaa', 'bbb', 'ccc'])
normal! 3Gmt1G
:'t
! assert_equal(3, getcurpos()[1])
bwipe!

MyFunc(
--- 604,671 ----
var = arg
enddef
MyFunc('foobar')
! var->assert_equal('foobar')

let str = 'barfoo'
str->MyFunc()
! var->assert_equal('barfoo')

g:value = 'value'
g:value->MyFunc()
! var->assert_equal('value')

let listvar = []
def ListFunc(arg: list<number>)
listvar = arg
enddef
[1, 2, 3]->ListFunc()
! listvar->assert_equal([1, 2, 3])

let dictvar = {}
def DictFunc(arg: dict<number>)
dictvar = arg
enddef
{'a': 1, 'b': 2}->DictFunc()
! dictvar->assert_equal(#{a: 1, b: 2})
def CompiledDict()
{'a': 3, 'b': 4}->DictFunc()
enddef
CompiledDict()
! dictvar->assert_equal(#{a: 3, b: 4})

#{a: 3, b: 4}->DictFunc()
! dictvar->assert_equal(#{a: 3, b: 4})

('text')->MyFunc()
! var->assert_equal('text')
("some")->MyFunc()
! var->assert_equal('some')

# line starting with single quote is not a mark
# line starting with double quote can be a method call
'asdfasdf'->MyFunc()
! var->assert_equal('asdfasdf')
"xyz"->MyFunc()
! var->assert_equal('xyz')

def UseString()
'xyork'->MyFunc()
enddef
UseString()
! var->assert_equal('xyork')

def UseString2()
"knife"->MyFunc()
enddef
UseString2()
! var->assert_equal('knife')

# prepending a colon makes it a mark
new
setline(1, ['aaa', 'bbb', 'ccc'])
normal! 3Gmt1G
:'t
! getcurpos()[1]->assert_equal(3)
bwipe!

MyFunc(
***************
*** 770,778 ****
so Xdef
delete('Xdef')

! assert_equal(0, g:Func0())
! assert_equal('Func1', g:Func1())
! assert_equal('Func2', g:Func2())

delfunc! Func0
delfunc! Func1
--- 770,778 ----
so Xdef
delete('Xdef')

! g:Func0()->assert_equal(0)
! g:Func1()->assert_equal('Func1')
! g:Func2()->assert_equal('Func2')

delfunc! Func0
delfunc! Func1
***************
*** 823,834 ****
call writefile(lines, 'Xscript')
source Xscript

! call assert_equal(2.0, RetFloat())
! call assert_equal([['k', 'v']], RetListAny())
! call assert_equal(['a', 'b', 'c'], RetListString())
! call assert_notequal([], RetListDictAny())
! call assert_notequal({}, RetDictNumber())
! call assert_notequal({}, RetDictString())
call delete('Xscript')
endfunc

--- 823,834 ----
call writefile(lines, 'Xscript')
source Xscript

! call RetFloat()->assert_equal(2.0)
! call RetListAny()->assert_equal([['k', 'v']])
! call RetListString()->assert_equal(['a', 'b', 'c'])
! call RetListDictAny()->assert_notequal([])
! call RetDictNumber()->assert_notequal({})
! call RetDictString()->assert_notequal({})
call delete('Xscript')
endfunc

***************
*** 895,922 ****
s:funcResult = 0
Ref1 = FuncNoArgNoRet
Ref1()
! assert_equal(11, s:funcResult)

let Ref2: func
s:funcResult = 0
Ref2 = FuncNoArgNoRet
Ref2()
! assert_equal(11, s:funcResult)

s:funcResult = 0
Ref2 = FuncOneArgNoRet
Ref2(12)
! assert_equal(12, s:funcResult)

s:funcResult = 0
Ref2 = FuncNoArgRetNumber
! assert_equal(1234, Ref2())
! assert_equal(22, s:funcResult)

s:funcResult = 0
Ref2 = FuncOneArgRetNumber
! assert_equal(13, Ref2(13))
! assert_equal(13, s:funcResult)
enddef

def Test_repeat_return_type()
--- 895,922 ----
s:funcResult = 0
Ref1 = FuncNoArgNoRet
Ref1()
! s:funcResult->assert_equal(11)

let Ref2: func
s:funcResult = 0
Ref2 = FuncNoArgNoRet
Ref2()
! s:funcResult->assert_equal(11)

s:funcResult = 0
Ref2 = FuncOneArgNoRet
Ref2(12)
! s:funcResult->assert_equal(12)

s:funcResult = 0
Ref2 = FuncNoArgRetNumber
! Ref2()->assert_equal(1234)
! s:funcResult->assert_equal(22)

s:funcResult = 0
Ref2 = FuncOneArgRetNumber
! Ref2(13)->assert_equal(13)
! s:funcResult->assert_equal(13)
enddef

def Test_repeat_return_type()
***************
*** 924,936 ****
for n in repeat([1], 3)
res += n
endfor
! assert_equal(3, res)

res = 0
for n in add([1, 2], 3)
res += n
endfor
! assert_equal(6, res)
enddef

def Test_argv_return_type()
--- 924,936 ----
for n in repeat([1], 3)
res += n
endfor
! res->assert_equal(3)

res = 0
for n in add([1, 2], 3)
res += n
endfor
! res->assert_equal(6)
enddef

def Test_argv_return_type()
***************
*** 939,945 ****
for name in argv()
res ..= name
endfor
! assert_equal('fileonefiletwo', res)
enddef

def Test_func_type_part()
--- 939,945 ----
for name in argv()
res ..= name
endfor
! res->assert_equal('fileonefiletwo')
enddef

def Test_func_type_part()
***************
*** 987,1000 ****
def Test_func_return_type()
let nr: number
nr = FuncNoArgRetNumber()
! assert_equal(1234, nr)

nr = FuncOneArgRetAny(122)
! assert_equal(122, nr)

let str: string
str = FuncOneArgRetAny('yes')
! assert_equal('yes', str)

CheckDefFailure(['let str: string', 'str = FuncNoArgRetNumber()'], 'E1012: type mismatch, expected string but got number')
enddef
--- 987,1000 ----
def Test_func_return_type()
let nr: number
nr = FuncNoArgRetNumber()
! nr->assert_equal(1234)

nr = FuncOneArgRetAny(122)
! nr->assert_equal(122)

let str: string
str = FuncOneArgRetAny('yes')
! str->assert_equal('yes')

CheckDefFailure(['let str: string', 'str = FuncNoArgRetNumber()'], 'E1012: type mismatch, expected string but got number')
enddef
***************
*** 1016,1032 ****
enddef

def Test_multiline()
! assert_equal('text1234', MultiLine('text'))
! assert_equal('text777', MultiLine('text', 777))
! assert_equal('text777one', MultiLine('text', 777, 'one'))
! assert_equal('text777one-two', MultiLine('text', 777, 'one', 'two'))
enddef

func Test_multiline_not_vim9()
! call assert_equal('text1234', MultiLine('text'))
! call assert_equal('text777', MultiLine('text', 777))
! call assert_equal('text777one', MultiLine('text', 777, 'one'))
! call assert_equal('text777one-two', MultiLine('text', 777, 'one', 'two'))
endfunc


--- 1016,1032 ----
enddef

def Test_multiline()
! MultiLine('text')->assert_equal('text1234')
! MultiLine('text', 777)->assert_equal('text777')
! MultiLine('text', 777, 'one')->assert_equal('text777one')
! MultiLine('text', 777, 'one', 'two')->assert_equal('text777one-two')
enddef

func Test_multiline_not_vim9()
! call MultiLine('text')->assert_equal('text1234')
! call MultiLine('text', 777)->assert_equal('text777')
! call MultiLine('text', 777, 'one')->assert_equal('text777one')
! call MultiLine('text', 777, 'one', 'two')->assert_equal('text777one-two')
endfunc


***************
*** 1041,1047 ****
catch /E1056:/
let caught_1056 = 1
endtry
! call assert_equal(1, caught_1056)

let caught_1059 = 0
try
--- 1041,1047 ----
catch /E1056:/
let caught_1056 = 1
endtry
! eval caught_1056->assert_equal(1)

let caught_1059 = 0
try
***************
*** 1051,1057 ****
catch /E1059:/
let caught_1059 = 1
endtry
! call assert_equal(1, caught_1059)
endfunc

func DelMe()
--- 1051,1057 ----
catch /E1059:/
let caught_1059 = 1
endtry
! eval caught_1059->assert_equal(1)
endfunc

func DelMe()
***************
*** 1074,1081 ****
source Xdef
assert_report('should have failed')
catch /E476:/
! assert_match('Invalid command: invalid', v:exception)
! assert_match(', line 3$', v:throwpoint)
endtry

# comment lines after the start of the function
--- 1074,1081 ----
source Xdef
assert_report('should have failed')
catch /E476:/
! v:exception->assert_match('Invalid command: invalid')
! v:throwpoint->assert_match(', line 3$')
endtry

# comment lines after the start of the function
***************
*** 1094,1101 ****
source Xdef
assert_report('should have failed')
catch /E476:/
! assert_match('Invalid command: invalid', v:exception)
! assert_match(', line 4$', v:throwpoint)
endtry

lines =<< trim END
--- 1094,1101 ----
source Xdef
assert_report('should have failed')
catch /E476:/
! v:exception->assert_match('Invalid command: invalid')
! v:throwpoint->assert_match(', line 4$')
endtry

lines =<< trim END
***************
*** 1113,1119 ****
source Xdef
assert_report('should have failed')
catch /E716:/
! assert_match('_Func, line 3$', v:throwpoint)
endtry

call delete('Xdef')
--- 1113,1119 ----
source Xdef
assert_report('should have failed')
catch /E716:/
! v:throwpoint->assert_match('_Func, line 3$')
endtry

call delete('Xdef')
***************
*** 1138,1144 ****

def Test_closure_simple()
let local = 'some '
! assert_equal('some more', RefFunc({s -> local .. s}))
enddef

def MakeRef()
--- 1138,1144 ----

def Test_closure_simple()
let local = 'some '
! RefFunc({s -> local .. s})->assert_equal('some more')
enddef

def MakeRef()
***************
*** 1148,1154 ****

def Test_closure_ref_after_return()
MakeRef()
! assert_equal('some thing', g:Ref('thing'))
unlet g:Ref
enddef

--- 1148,1154 ----

def Test_closure_ref_after_return()
MakeRef()
! g:Ref('thing')->assert_equal('some thing')
unlet g:Ref
enddef

***************
*** 1160,1170 ****

def Test_closure_two_refs()
MakeTwoRefs()
! assert_equal('some', join(g:Read(), ' '))
g:Extend('more')
! assert_equal('some more', join(g:Read(), ' '))
g:Extend('even')
! assert_equal('some more even', join(g:Read(), ' '))

unlet g:Extend
unlet g:Read
--- 1160,1170 ----

def Test_closure_two_refs()
MakeTwoRefs()
! join(g:Read(), ' ')->assert_equal('some')
g:Extend('more')
! join(g:Read(), ' ')->assert_equal('some more')
g:Extend('even')
! join(g:Read(), ' ')->assert_equal('some more even')

unlet g:Extend
unlet g:Read
***************
*** 1180,1190 ****

def Test_closure_two_indirect_refs()
MakeTwoRefs()
! assert_equal('some', ReadRef(g:Read))
ExtendRef(g:Extend, 'more')
! assert_equal('some more', ReadRef(g:Read))
ExtendRef(g:Extend, 'even')
! assert_equal('some more even', ReadRef(g:Read))

unlet g:Extend
unlet g:Read
--- 1180,1190 ----

def Test_closure_two_indirect_refs()
MakeTwoRefs()
! ReadRef(g:Read)->assert_equal('some')
ExtendRef(g:Extend, 'more')
! ReadRef(g:Read)->assert_equal('some more')
ExtendRef(g:Extend, 'even')
! ReadRef(g:Read)->assert_equal('some more even')

unlet g:Extend
unlet g:Read
***************
*** 1202,1211 ****

def Test_closure_using_argument()
MakeArgRefs('arg_val')
! assert_equal('arg_val/loc_val/call_val', g:UseArg('call_val'))

MakeArgRefsVarargs('arg_val', 'one', 'two')
! assert_equal('arg_val/the_loc/call_val/one two', g:UseVararg('call_val'))

unlet g:UseArg
unlet g:UseVararg
--- 1202,1211 ----

def Test_closure_using_argument()
MakeArgRefs('arg_val')
! g:UseArg('call_val')->assert_equal('arg_val/loc_val/call_val')

MakeArgRefsVarargs('arg_val', 'one', 'two')
! g:UseVararg('call_val')->assert_equal('arg_val/the_loc/call_val/one two')

unlet g:UseArg
unlet g:UseVararg
***************
*** 1227,1237 ****

def Test_closure_append_get()
MakeGetAndAppendRefs()
! assert_equal('a', g:Get())
g:Append('-b')
! assert_equal('a-b', g:Get())
g:Append('-c')
! assert_equal('a-b-c', g:Get())

unlet g:Append
unlet g:Get
--- 1227,1237 ----

def Test_closure_append_get()
MakeGetAndAppendRefs()
! g:Get()->assert_equal('a')
g:Append('-b')
! g:Get()->assert_equal('a-b')
g:Append('-c')
! g:Get()->assert_equal('a-b-c')

unlet g:Append
unlet g:Get
***************
*** 1242,1248 ****
def Closure(arg: string): string
return local .. arg
enddef
! assert_equal('text!!!', Closure('!!!'))
enddef

func GetResult(Ref)
--- 1242,1248 ----
def Closure(arg: string): string
return local .. arg
enddef
! Closure('!!!')->assert_equal('text!!!')
enddef

func GetResult(Ref)
***************
*** 1252,1258 ****
def Test_call_closure_not_compiled()
let text = 'text'
g:Ref = {s -> s .. text}
! assert_equal('sometext', GetResult(g:Ref))
enddef

def Test_sort_return_type()
--- 1252,1258 ----
def Test_call_closure_not_compiled()
let text = 'text'
g:Ref = {s -> s .. text}
! GetResult(g:Ref)->assert_equal('sometext')
enddef

def Test_sort_return_type()
***************
*** 1262,1279 ****

def Test_getqflist_return_type()
let l = getqflist()
! assert_equal([], l)

let d = getqflist(#{items: 0})
! assert_equal(#{items: []}, d)
enddef

def Test_getloclist_return_type()
let l = getloclist(1)
! assert_equal([], l)

let d = getloclist(1, #{items: 0})
! assert_equal(#{items: []}, d)
enddef

def Test_copy_return_type()
--- 1262,1279 ----

def Test_getqflist_return_type()
let l = getqflist()
! l->assert_equal([])

let d = getqflist(#{items: 0})
! d->assert_equal(#{items: []})
enddef

def Test_getloclist_return_type()
let l = getloclist(1)
! l->assert_equal([])

let d = getloclist(1, #{items: 0})
! d->assert_equal(#{items: []})
enddef

def Test_copy_return_type()
***************
*** 1282,1295 ****
for n in l
res += n
endfor
! assert_equal(6, res)

let dl = deepcopy([1, 2, 3])
res = 0
for n in dl
res += n
endfor
! assert_equal(6, res)

dl = deepcopy([1, 2, 3], true)
enddef
--- 1282,1295 ----
for n in l
res += n
endfor
! res->assert_equal(6)

let dl = deepcopy([1, 2, 3])
res = 0
for n in dl
res += n
endfor
! res->assert_equal(6)

dl = deepcopy([1, 2, 3], true)
enddef
***************
*** 1300,1306 ****
for n in l
res += n
endfor
! assert_equal(6, res)
enddef

def Test_garbagecollect()
--- 1300,1306 ----
for n in l
res += n
endfor
! res->assert_equal(6)
enddef

def Test_garbagecollect()
***************
*** 1313,1324 ****
for n in l
res += n
endfor
! assert_equal(6, res)
enddef

def Test_keys_return_type()
const var: list<string> = #{a: 1, b: 2}->keys()
! assert_equal(['a', 'b'], var)
enddef

def Test_reverse_return_type()
--- 1313,1324 ----
for n in l
res += n
endfor
! res->assert_equal(6)
enddef

def Test_keys_return_type()
const var: list<string> = #{a: 1, b: 2}->keys()
! var->assert_equal(['a', 'b'])
enddef

def Test_reverse_return_type()
***************
*** 1327,1333 ****
for n in l
res += n
endfor
! assert_equal(6, res)
enddef

def Test_remove_return_type()
--- 1327,1333 ----
for n in l
res += n
endfor
! res->assert_equal(6)
enddef

def Test_remove_return_type()
***************
*** 1336,1342 ****
for n in l
res += n
endfor
! assert_equal(3, res)
enddef

def Test_filter_return_type()
--- 1336,1342 ----
for n in l
res += n
endfor
! res->assert_equal(3)
enddef

def Test_filter_return_type()
***************
*** 1345,1370 ****
for n in l
res += n
endfor
! assert_equal(6, res)
enddef

def Test_bufnr()
let buf = bufnr()
! assert_equal(buf, bufnr('%'))

buf = bufnr('Xdummy', true)
! assert_notequal(-1, buf)
exe 'bwipe! ' .. buf
enddef

def Test_col()
new
setline(1, 'asdf')
! assert_equal(5, col([1, '$']))
enddef

def Test_char2nr()
! assert_equal(12354, char2nr('あ', true))
enddef

def Test_getreg_return_type()
--- 1345,1370 ----
for n in l
res += n
endfor
! res->assert_equal(6)
enddef

def Test_bufnr()
let buf = bufnr()
! bufnr('%')->assert_equal(buf)

buf = bufnr('Xdummy', true)
! buf->assert_notequal(-1)
exe 'bwipe! ' .. buf
enddef

def Test_col()
new
setline(1, 'asdf')
! col([1, '$'])->assert_equal(5)
enddef

def Test_char2nr()
! char2nr('あ', true)->assert_equal(12354)
enddef

def Test_getreg_return_type()
***************
*** 1389,1395 ****
enddef

def Test_line_continuation_in_def()
! assert_equal('full', Line_continuation_in_def('.'))
enddef

def Line_continuation_in_lambda(): list<number>
--- 1389,1395 ----
enddef

def Test_line_continuation_in_def()
! Line_continuation_in_def('.')->assert_equal('full')
enddef

def Line_continuation_in_lambda(): list<number>
***************
*** 1401,1407 ****
enddef

def Test_line_continuation_in_lambda()
! assert_equal(['D', 'C', 'B', 'A'], Line_continuation_in_lambda())
enddef

func Test_silent_echo()
--- 1401,1407 ----
enddef

def Test_line_continuation_in_lambda()
! Line_continuation_in_lambda()->assert_equal(['D', 'C', 'B', 'A'])
enddef

func Test_silent_echo()
***************
*** 1430,1438 ****

def Test_bufname()
split SomeFile
! assert_equal('SomeFile', bufname('%'))
edit OtherFile
! assert_equal('SomeFile', bufname('#'))
close
enddef

--- 1430,1438 ----

def Test_bufname()
split SomeFile
! bufname('%')->assert_equal('SomeFile')
edit OtherFile
! bufname('#')->assert_equal('SomeFile')
close
enddef

***************
*** 1442,1448 ****
let SomeFileID = win_getid()
below split OtherFile
below split SomeFile
! assert_equal(SomeFileID, bufwinid('SomeFile'))

win_gotoid(origwin)
only
--- 1442,1448 ----
let SomeFileID = win_getid()
below split OtherFile
below split SomeFile
! bufwinid('SomeFile')->assert_equal(SomeFileID)

win_gotoid(origwin)
only
***************
*** 1451,1469 ****
enddef

def Test_count()
! assert_equal(3, count('ABC ABC ABC', 'b', true))
! assert_equal(0, count('ABC ABC ABC', 'b', false))
enddef

def Test_expand()
split SomeFile
! assert_equal(['SomeFile'], expand('%', true, true))
close
enddef

def Test_getbufinfo()
let bufinfo = getbufinfo(bufnr())
! assert_equal(bufinfo, getbufinfo('%'))

edit Xtestfile1
hide edit Xtestfile2
--- 1451,1469 ----
enddef

def Test_count()
! count('ABC ABC ABC', 'b', true)->assert_equal(3)
! count('ABC ABC ABC', 'b', false)->assert_equal(0)
enddef

def Test_expand()
split SomeFile
! expand('%', true, true)->assert_equal(['SomeFile'])
close
enddef

def Test_getbufinfo()
let bufinfo = getbufinfo(bufnr())
! getbufinfo('%')->assert_equal(bufinfo)

edit Xtestfile1
hide edit Xtestfile2
***************
*** 1479,1485 ****
e #
let lines = ['aaa', 'bbb', 'ccc']
setbufline(buf, 1, lines)
! assert_equal(lines, getbufline('#', 1, '$'))

bwipe!
enddef
--- 1479,1485 ----
e #
let lines = ['aaa', 'bbb', 'ccc']
setbufline(buf, 1, lines)
! getbufline('#', 1, '$')->assert_equal(lines)

bwipe!
enddef
***************
*** 1488,1544 ****
new
setline(1, 'some text')
let changelist = bufnr()->getchangelist()
! assert_equal(changelist, getchangelist('%'))
bwipe!
enddef

def Test_getchar()
while getchar(0)
endwhile
! assert_equal(0, getchar(true))
enddef

def Test_getcompletion()
set wildignore=*.vim,*~
let l = getcompletion('run', 'file', true)
! assert_equal([], l)
set wildignore&
enddef

def Test_getreg()
let lines = ['aaa', 'bbb', 'ccc']
setreg('a', lines)
! assert_equal(lines, getreg('a', true, true))
enddef

def Test_glob()
! assert_equal(['runtest.vim'], glob('runtest.vim', true, true, true))
enddef

def Test_globpath()
! assert_equal(['./runtest.vim'], globpath('.', 'runtest.vim', true, true, true))
enddef

def Test_has()
! assert_equal(1, has('eval', true))
enddef

def Test_hasmapto()
! assert_equal(0, hasmapto('foobar', 'i', true))
iabbrev foo foobar
! assert_equal(1, hasmapto('foobar', 'i', true))
iunabbrev foo
enddef

def Test_index()
! assert_equal(3, index(['a', 'b', 'a', 'B'], 'b', 2, true))
enddef

def Test_list2str_str2list_utf8()
let s = "\u3042\u3044"
let l = [0x3042, 0x3044]
! assert_equal(l, str2list(s, true))
! assert_equal(s, list2str(l, true))
enddef

def SID(): number
--- 1488,1544 ----
new
setline(1, 'some text')
let changelist = bufnr()->getchangelist()
! getchangelist('%')->assert_equal(changelist)
bwipe!
enddef

def Test_getchar()
while getchar(0)
endwhile
! getchar(true)->assert_equal(0)
enddef

def Test_getcompletion()
set wildignore=*.vim,*~
let l = getcompletion('run', 'file', true)
! l->assert_equal([])
set wildignore&
enddef

def Test_getreg()
let lines = ['aaa', 'bbb', 'ccc']
setreg('a', lines)
! getreg('a', true, true)->assert_equal(lines)
enddef

def Test_glob()
! glob('runtest.vim', true, true, true)->assert_equal(['runtest.vim'])
enddef

def Test_globpath()
! globpath('.', 'runtest.vim', true, true, true)->assert_equal(['./runtest.vim'])
enddef

def Test_has()
! has('eval', true)->assert_equal(1)
enddef

def Test_hasmapto()
! hasmapto('foobar', 'i', true)->assert_equal(0)
iabbrev foo foobar
! hasmapto('foobar', 'i', true)->assert_equal(1)
iunabbrev foo
enddef

def Test_index()
! index(['a', 'b', 'a', 'B'], 'b', 2, true)->assert_equal(3)
enddef

def Test_list2str_str2list_utf8()
let s = "\u3042\u3044"
let l = [0x3042, 0x3044]
! str2list(s, true)->assert_equal(l)
! list2str(l, true)->assert_equal(s)
enddef

def SID(): number
***************
*** 1550,1556 ****
def Test_maparg()
let lnum = str2nr(expand('<sflnum>'))
map foo bar
! assert_equal(#{
lnum: lnum + 1,
script: 0,
mode: ' ',
--- 1550,1556 ----
def Test_maparg()
let lnum = str2nr(expand('<sflnum>'))
map foo bar
! maparg('foo', '', false, true)->assert_equal(#{
lnum: lnum + 1,
script: 0,
mode: ' ',
***************
*** 1562,1580 ****
expr: 0,
sid: SID(),
rhs: 'bar',
! buffer: 0},
! maparg('foo', '', false, true))
unmap foo
enddef

def Test_mapcheck()
iabbrev foo foobar
! assert_equal('foobar', mapcheck('foo', 'i', true))
iunabbrev foo
enddef

def Test_nr2char()
! assert_equal('a', nr2char(97, true))
enddef

def Test_readdir()
--- 1562,1579 ----
expr: 0,
sid: SID(),
rhs: 'bar',
! buffer: 0})
unmap foo
enddef

def Test_mapcheck()
iabbrev foo foobar
! mapcheck('foo', 'i', true)->assert_equal('foobar')
iunabbrev foo
enddef

def Test_nr2char()
! nr2char(97, true)->assert_equal('a')
enddef

def Test_readdir()
***************
*** 1587,1600 ****
setline(1, ['foo', 'bar'])
let val = 0
# skip expr returns boolean
! assert_equal(2, search('bar', 'W', 0, 0, {-> val == 1}))
:1
! assert_equal(0, search('bar', 'W', 0, 0, {-> val == 0}))
# skip expr returns number, only 0 and 1 are accepted
:1
! assert_equal(2, search('bar', 'W', 0, 0, {-> 0}))
:1
! assert_equal(0, search('bar', 'W', 0, 0, {-> 1}))
assert_fails("search('bar', '', 0, 0, {-> -1})", 'E1023:')
assert_fails("search('bar', '', 0, 0, {-> -1})", 'E1023:')
enddef
--- 1586,1599 ----
setline(1, ['foo', 'bar'])
let val = 0
# skip expr returns boolean
! search('bar', 'W', 0, 0, {-> val == 1})->assert_equal(2)
:1
! search('bar', 'W', 0, 0, {-> val == 0})->assert_equal(0)
# skip expr returns number, only 0 and 1 are accepted
:1
! search('bar', 'W', 0, 0, {-> 0})->assert_equal(2)
:1
! search('bar', 'W', 0, 0, {-> 1})->assert_equal(0)
assert_fails("search('bar', '', 0, 0, {-> -1})", 'E1023:')
assert_fails("search('bar', '', 0, 0, {-> -1})", 'E1023:')
enddef
***************
*** 1603,1635 ****
new
setline(1, "foo bar")
:/foo
! assert_equal(#{
! exact_match: 1,
! current: 1,
! total: 1,
! maxcount: 99,
! incomplete: 0,
! }, searchcount(#{recompute: true}))
bwipe!
enddef

def Test_searchdecl()
! assert_equal(1, searchdecl('blah', true, true))
enddef

def Test_setbufvar()
! setbufvar(bufnr('%'), '&syntax', 'vim')
! assert_equal('vim', &syntax)
! setbufvar(bufnr('%'), '&ts', 16)
! assert_equal(16, &ts)
! settabwinvar(1, 1, '&syntax', 'vam')
! assert_equal('vam', &syntax)
! settabwinvar(1, 1, '&ts', 15)
! assert_equal(15, &ts)
! setlocal ts=8

! setbufvar('%', 'myvar', 123)
! assert_equal(123, getbufvar('%', 'myvar'))
enddef

def Test_setloclist()
--- 1602,1634 ----
new
setline(1, "foo bar")
:/foo
! searchcount(#{recompute: true})
! ->assert_equal(#{
! exact_match: 1,
! current: 1,
! total: 1,
! maxcount: 99,
! incomplete: 0})
bwipe!
enddef

def Test_searchdecl()
! searchdecl('blah', true, true)->assert_equal(1)
enddef

def Test_setbufvar()
! setbufvar(bufnr('%'), '&syntax', 'vim')
! &syntax->assert_equal('vim')
! setbufvar(bufnr('%'), '&ts', 16)
! &ts->assert_equal(16)
! settabwinvar(1, 1, '&syntax', 'vam')
! &syntax->assert_equal('vam')
! settabwinvar(1, 1, '&ts', 15)
! &ts->assert_equal(15)
! setlocal ts=8

! setbufvar('%', 'myvar', 123)
! getbufvar('%', 'myvar')->assert_equal(123)
enddef

def Test_setloclist()
***************
*** 1643,1649 ****
setreg('a', ['aaa', 'bbb', 'ccc'])
let reginfo = getreginfo('a')
setreg('a', reginfo)
! assert_equal(reginfo, getreginfo('a'))
enddef

def Test_spellsuggest()
--- 1642,1648 ----
setreg('a', ['aaa', 'bbb', 'ccc'])
let reginfo = getreginfo('a')
setreg('a', reginfo)
! getreginfo('a')->assert_equal(reginfo)
enddef

def Test_spellsuggest()
***************
*** 1671,1683 ****
let Rep = {-> range(10)->map({_, v -> submatch(v, true)})->string()}
let actual = substitute('A123456789', pat, Rep, '')
let expected = "[['A123456789'], ['1'], ['2'], ['3'], ['4'], ['5'], ['6'], ['7'], ['8'], ['9']]"
! assert_equal(expected, actual)
enddef

def Test_synID()
new
setline(1, "text")
! assert_equal(0, synID(1, 1, true))
bwipe!
enddef

--- 1670,1682 ----
let Rep = {-> range(10)->map({_, v -> submatch(v, true)})->string()}
let actual = substitute('A123456789', pat, Rep, '')
let expected = "[['A123456789'], ['1'], ['2'], ['3'], ['4'], ['5'], ['6'], ['7'], ['8'], ['9']]"
! actual->assert_equal(expected)
enddef

def Test_synID()
new
setline(1, "text")
! synID(1, 1, true)->assert_equal(0)
bwipe!
enddef

***************
*** 1686,1692 ****
MissingFeature 'terminal'
else
let buf = Run_shell_in_terminal({})
! assert_notequal('', term_gettty(buf, true))
StopShellInTerminal(buf)
endif
enddef
--- 1685,1691 ----
MissingFeature 'terminal'
else
let buf = Run_shell_in_terminal({})
! term_gettty(buf, true)->assert_notequal('')
StopShellInTerminal(buf)
endif
enddef
***************
*** 1698,1704 ****
botright new
let winnr = winnr()
term_start(&shell, #{curwin: true})
! assert_equal(winnr, winnr())
bwipe!
endif
enddef
--- 1697,1703 ----
botright new
let winnr = winnr()
term_start(&shell, #{curwin: true})
! winnr()->assert_equal(winnr)
bwipe!
endif
enddef
***************
*** 1707,1713 ****
let id = timer_start(50, {-> 0})
timer_pause(id, true)
let info = timer_info(id)
! assert_equal(1, info[0]['paused'])
timer_stop(id)
enddef

--- 1706,1712 ----
let id = timer_start(50, {-> 0})
timer_pause(id, true)
let info = timer_info(id)
! info[0]['paused']->assert_equal(1)
timer_stop(id)
enddef

***************
*** 1728,1734 ****
enddef

def Test_recursive_call()
! assert_equal(6765, Fibonacci(20))
enddef

def TreeWalk(dir: string): list<any>
--- 1727,1733 ----
enddef

def Test_recursive_call()
! Fibonacci(20)->assert_equal(6765)
enddef

def TreeWalk(dir: string): list<any>
***************
*** 1745,1751 ****
writefile(['222'], 'XclosureDir/file2')
writefile(['333'], 'XclosureDir/tdir/file3')

! assert_equal(['file1', 'file2', {'tdir': ['file3']}], TreeWalk('XclosureDir'))

delete('XclosureDir', 'rf')
enddef
--- 1744,1750 ----
writefile(['222'], 'XclosureDir/file2')
writefile(['333'], 'XclosureDir/tdir/file3')

! TreeWalk('XclosureDir')->assert_equal(['file1', 'file2', {'tdir': ['file3']}])

delete('XclosureDir', 'rf')
enddef
***************
*** 1753,1771 ****
def Test_partial_call()
let Xsetlist = function('setloclist', [0])
Xsetlist([], ' ', {'title': 'test'})
! assert_equal({'title': 'test'}, getloclist(0, {'title': 1}))

Xsetlist = function('setloclist', [0, [], ' '])
Xsetlist({'title': 'test'})
! assert_equal({'title': 'test'}, getloclist(0, {'title': 1}))

Xsetlist = function('setqflist')
Xsetlist([], ' ', {'title': 'test'})
! assert_equal({'title': 'test'}, getqflist({'title': 1}))

Xsetlist = function('setqflist', [[], ' '])
Xsetlist({'title': 'test'})
! assert_equal({'title': 'test'}, getqflist({'title': 1}))
enddef

def Test_cmd_modifier()
--- 1752,1770 ----
def Test_partial_call()
let Xsetlist = function('setloclist', [0])
Xsetlist([], ' ', {'title': 'test'})
! getloclist(0, {'title': 1})->assert_equal({'title': 'test'})

Xsetlist = function('setloclist', [0, [], ' '])
Xsetlist({'title': 'test'})
! getloclist(0, {'title': 1})->assert_equal({'title': 'test'})

Xsetlist = function('setqflist')
Xsetlist([], ' ', {'title': 'test'})
! getqflist({'title': 1})->assert_equal({'title': 'test'})

Xsetlist = function('setqflist', [[], ' '])
Xsetlist({'title': 'test'})
! getqflist({'title': 1})->assert_equal({'title': 'test'})
enddef

def Test_cmd_modifier()
***************
*** 1790,1796 ****
Func()
END
CheckScriptSuccess(lines)
! assert_equal('', g:ei_after)
enddef

def StackTop()
--- 1789,1795 ----
Func()
END
CheckScriptSuccess(lines)
! g:ei_after->assert_equal('')
enddef

def StackTop()
***************
*** 1809,1815 ****
try
StackTop()
catch
! assert_match('Test_callstack_def\[2\]..StackTop\[4\]..StackBot, line 2', v:throwpoint)
endtry
enddef

--- 1808,1814 ----
try
StackTop()
catch
! v:throwpoint->assert_match('Test_callstack_def\[2\]..StackTop\[4\]..StackBot, line 2')
endtry
enddef

*** ../vim-8.2.1659/src/version.c 2020-09-11 18:11:45.098325224 +0200
--- src/version.c 2020-09-11 19:09:12.431964775 +0200
***************
*** 752,753 ****
--- 752,755 ----
{ /* Add new patch number below this line */
+ /**/
+ 1660,
/**/

--
Permission is granted to read this message out aloud on Kings Cross Road,
London, under the condition that the orator is properly dressed.

/// Bram Moolenaar -- Br...@Moolenaar.net -- http://www.Moolenaar.net \\\
/// sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ \\\
\\\ an exciting new programming language -- http://www.Zimbu.org ///
\\\ help me help AIDS victims -- http://ICCF-Holland.org ///