blob: 1449017ca9fabcb3cb8115b566090470dccb8f25 [file] [log] [blame]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001" Test various aspects of the Vim9 script language.
2
Bram Moolenaar673660a2020-01-26 16:50:05 +01003source check.vim
Bram Moolenaarad39c092020-02-26 18:23:43 +01004source view_util.vim
Bram Moolenaar673660a2020-01-26 16:50:05 +01005
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01006" Check that "lines" inside ":def" results in an "error" message.
7func CheckDefFailure(lines, error)
Bram Moolenaar978d1702020-01-26 17:38:12 +01008 call writefile(['def Func()'] + a:lines + ['enddef'], 'Xdef')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009 call assert_fails('so Xdef', a:error, a:lines)
10 call delete('Xdef')
11endfunc
12
13func CheckScriptFailure(lines, error)
14 call writefile(a:lines, 'Xdef')
15 call assert_fails('so Xdef', a:error, a:lines)
16 call delete('Xdef')
17endfunc
18
19def Test_syntax()
20 let var = 234
21 let other: list<string> = ['asdf']
22enddef
23
24func Test_def_basic()
25 def SomeFunc(): string
26 return 'yes'
27 enddef
28 call assert_equal('yes', SomeFunc())
29endfunc
30
Bram Moolenaar6e587dc2020-02-06 13:15:52 +010031let s:appendToMe = 'xxx'
32let s:addToMe = 111
Bram Moolenaar401d9ff2020-02-19 18:14:44 +010033let g:existing = 'yes'
Bram Moolenaara8c17702020-04-01 21:17:24 +020034let g:inc_counter = 1
35let $SOME_ENV_VAR = 'some'
Bram Moolenaar6e587dc2020-02-06 13:15:52 +010036
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010037def Test_assignment()
38 let bool1: bool = true
39 assert_equal(v:true, bool1)
40 let bool2: bool = false
41 assert_equal(v:false, bool2)
42
Bram Moolenaar0c2ca582020-02-25 22:58:29 +010043 let list1: list<bool> = [false, true, false]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010044 let list2: list<number> = [1, 2, 3]
Bram Moolenaar0c2ca582020-02-25 22:58:29 +010045 let list3: list<string> = ['sdf', 'asdf']
46 let list4: list<any> = ['yes', true, 1234]
47 let list5: list<blob> = [0z01, 0z02]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010048
Bram Moolenaar436472f2020-02-20 22:54:43 +010049 let listS: list<string> = []
50 let listN: list<number> = []
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010051
Bram Moolenaar0c2ca582020-02-25 22:58:29 +010052 let dict1: dict<bool> = #{one: false, two: true}
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010053 let dict2: dict<number> = #{one: 1, two: 2}
Bram Moolenaar0c2ca582020-02-25 22:58:29 +010054 let dict3: dict<string> = #{key: 'value'}
55 let dict4: dict<any> = #{one: 1, two: '2'}
56 let dict5: dict<blob> = #{one: 0z01, tw: 0z02}
Bram Moolenaarb283a8a2020-02-02 22:24:04 +010057
Bram Moolenaar9be61bb2020-03-30 22:51:24 +020058 let a: number = 6
59 assert_equal(6, a)
60
Bram Moolenaar42a480b2020-02-29 23:23:47 +010061 if has('channel')
62 let chan1: channel
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +010063 let job1: job
Bram Moolenaarf51cb4e2020-03-01 17:55:14 +010064 let job2: job = job_start('willfail')
Bram Moolenaar42a480b2020-02-29 23:23:47 +010065 endif
Bram Moolenaarfbdd08e2020-03-01 14:04:46 +010066 if has('float')
67 let float1: float = 3.4
68 endif
Bram Moolenaar087d2e12020-03-01 15:36:42 +010069 let funky1: func
70 let funky2: func = function('len')
71 let party1: partial
72 let party2: partial = funcref('Test_syntax')
Bram Moolenaar42a480b2020-02-29 23:23:47 +010073
Bram Moolenaar61a6d4e2020-03-01 23:32:25 +010074 " type becomes list<any>
75 let somelist = rand() > 0 ? [1, 2, 3] : ['a', 'b', 'c']
Bram Moolenaar5381c7a2020-03-02 22:53:32 +010076 " type becomes dict<any>
77 let somedict = rand() > 0 ? #{a: 1, b: 2} : #{a: 'a', b: 'b'}
Bram Moolenaar61a6d4e2020-03-01 23:32:25 +010078
Bram Moolenaar401d9ff2020-02-19 18:14:44 +010079 g:newvar = 'new'
80 assert_equal('new', g:newvar)
81
82 assert_equal('yes', g:existing)
83 g:existing = 'no'
84 assert_equal('no', g:existing)
85
Bram Moolenaarb283a8a2020-02-02 22:24:04 +010086 v:char = 'abc'
Bram Moolenaar6e587dc2020-02-06 13:15:52 +010087 assert_equal('abc', v:char)
Bram Moolenaarb283a8a2020-02-02 22:24:04 +010088
89 $ENVVAR = 'foobar'
Bram Moolenaar6e587dc2020-02-06 13:15:52 +010090 assert_equal('foobar', $ENVVAR)
Bram Moolenaarb283a8a2020-02-02 22:24:04 +010091 $ENVVAR = ''
Bram Moolenaar6e587dc2020-02-06 13:15:52 +010092
Bram Moolenaarfd1823e2020-02-19 20:23:11 +010093 s:appendToMe ..= 'yyy'
94 assert_equal('xxxyyy', s:appendToMe)
95 s:addToMe += 222
96 assert_equal(333, s:addToMe)
Bram Moolenaar0bbf7222020-02-19 22:31:48 +010097 s:newVar = 'new'
98 assert_equal('new', s:newVar)
Bram Moolenaara8c17702020-04-01 21:17:24 +020099
100 set ts=7
101 &ts += 1
102 assert_equal(8, &ts)
103 call CheckDefFailure(['&notex += 3'], 'E113:')
104 call CheckDefFailure(['&ts ..= "xxx"'], 'E1019:')
105 call CheckDefFailure(['&path += 3'], 'E1013:')
106
107 g:inc_counter += 1
108 assert_equal(2, g:inc_counter)
109
110 $SOME_ENV_VAR ..= 'more'
111 assert_equal('somemore', $SOME_ENV_VAR)
112 call CheckDefFailure(['$SOME_ENV_VAR += "more"'], 'E1013:')
113 call CheckDefFailure(['$SOME_ENV_VAR += 123'], 'E1013:')
114
115 @a = 'areg'
116 @a ..= 'add'
117 assert_equal('aregadd', @a)
118 call CheckDefFailure(['@a += "more"'], 'E1013:')
119 call CheckDefFailure(['@a += 123'], 'E1013:')
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200120
121 v:errmsg = 'none'
122 v:errmsg ..= 'again'
123 assert_equal('noneagain', v:errmsg)
124 call CheckDefFailure(['v:errmsg += "more"'], 'E1013:')
125 call CheckDefFailure(['v:errmsg += 123'], 'E1013:')
126
127 " Test default values.
128 let thebool: bool
129 assert_equal(v:false, thebool)
130
131 let thenumber: number
132 assert_equal(0, thenumber)
133
134 if has('float')
135 let thefloat: float
136 assert_equal(0.0, thefloat)
137 endif
138
139 let thestring: string
140 assert_equal('', thestring)
141
142 let theblob: blob
143 assert_equal(0z, theblob)
144
145 let thefunc: func
146 assert_equal(test_null_function(), thefunc)
147
148 let thepartial: partial
149 assert_equal(test_null_partial(), thepartial)
150
151 let thelist: list<any>
152 assert_equal([], thelist)
153
154 let thedict: dict<any>
155 assert_equal({}, thedict)
156
157 let thejob: job
158 assert_equal(test_null_job(), thejob)
159
160 let thechannel: channel
161 assert_equal(test_null_channel(), thechannel)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100162enddef
163
164func Test_assignment_failure()
165 call CheckDefFailure(['let var=234'], 'E1004:')
166 call CheckDefFailure(['let var =234'], 'E1004:')
167 call CheckDefFailure(['let var= 234'], 'E1004:')
168
169 call CheckDefFailure(['let true = 1'], 'E1034:')
170 call CheckDefFailure(['let false = 1'], 'E1034:')
171
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200172 call CheckDefFailure(['let [a; b; c] = g:list'], 'E452:')
173
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200174 call CheckDefFailure(['let somevar'], "E1022:")
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200175 call CheckDefFailure(['let &option'], 'E1052:')
176 call CheckDefFailure(['&g:option = 5'], 'E113:')
177
178 call CheckDefFailure(['let $VAR = 5'], 'E1065:')
179
180 call CheckDefFailure(['let @~ = 5'], 'E354:')
181 call CheckDefFailure(['let @a = 5'], 'E1066:')
182
183 call CheckDefFailure(['let g:var = 5'], 'E1016:')
184
185 call CheckDefFailure(['let anr = 4', 'anr ..= "text"'], 'E1019:')
186 call CheckDefFailure(['let xnr += 4'], 'E1020:')
187
Bram Moolenaar33fa29c2020-03-28 19:41:33 +0100188 call CheckScriptFailure(['vim9script', 'def Func()', 'let dummy = s:notfound', 'enddef'], 'E1050:')
189
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100190 call CheckDefFailure(['let var: list<string> = [123]'], 'expected list<string> but got list<number>')
191 call CheckDefFailure(['let var: list<number> = ["xx"]'], 'expected list<number> but got list<string>')
192
193 call CheckDefFailure(['let var: dict<string> = #{key: 123}'], 'expected dict<string> but got dict<number>')
194 call CheckDefFailure(['let var: dict<number> = #{key: "xx"}'], 'expected dict<number> but got dict<string>')
195
196 call CheckDefFailure(['let var = feedkeys("0")'], 'E1031:')
197 call CheckDefFailure(['let var: number = feedkeys("0")'], 'expected number but got void')
Bram Moolenaar42a480b2020-02-29 23:23:47 +0100198
199 call CheckDefFailure(['let var: dict <number>'], 'E1007:')
200 call CheckDefFailure(['let var: dict<number'], 'E1009:')
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100201endfunc
202
203func Test_wrong_type()
204 call CheckDefFailure(['let var: list<nothing>'], 'E1010:')
205 call CheckDefFailure(['let var: list<list<nothing>>'], 'E1010:')
206 call CheckDefFailure(['let var: dict<nothing>'], 'E1010:')
207 call CheckDefFailure(['let var: dict<dict<nothing>>'], 'E1010:')
208
209 call CheckDefFailure(['let var: dict<number'], 'E1009:')
210 call CheckDefFailure(['let var: dict<list<number>'], 'E1009:')
Bram Moolenaar42a480b2020-02-29 23:23:47 +0100211
212 call CheckDefFailure(['let var: ally'], 'E1010:')
213 call CheckDefFailure(['let var: bram'], 'E1010:')
214 call CheckDefFailure(['let var: cathy'], 'E1010:')
215 call CheckDefFailure(['let var: dom'], 'E1010:')
216 call CheckDefFailure(['let var: freddy'], 'E1010:')
217 call CheckDefFailure(['let var: john'], 'E1010:')
218 call CheckDefFailure(['let var: larry'], 'E1010:')
219 call CheckDefFailure(['let var: ned'], 'E1010:')
220 call CheckDefFailure(['let var: pam'], 'E1010:')
221 call CheckDefFailure(['let var: sam'], 'E1010:')
222 call CheckDefFailure(['let var: vim'], 'E1010:')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100223endfunc
224
225func Test_const()
226 call CheckDefFailure(['const var = 234', 'var = 99'], 'E1018:')
227 call CheckDefFailure(['const one = 234', 'let one = 99'], 'E1017:')
228 call CheckDefFailure(['const two'], 'E1021:')
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200229 call CheckDefFailure(['const &option'], 'E996:')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100230endfunc
231
232def Test_block()
233 let outer = 1
234 {
235 let inner = 2
236 assert_equal(1, outer)
237 assert_equal(2, inner)
238 }
239 assert_equal(1, outer)
240enddef
241
242func Test_block_failure()
243 call CheckDefFailure(['{', 'let inner = 1', '}', 'echo inner'], 'E1001:')
244endfunc
245
246def ReturnString(): string
247 return 'string'
248enddef
249
250def ReturnNumber(): number
251 return 123
252enddef
253
Bram Moolenaar09f28f42020-02-20 23:08:34 +0100254let g:notNumber = 'string'
255
256def ReturnGlobal(): number
257 return g:notNumber
258enddef
259
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200260def Test_return_something()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100261 assert_equal('string', ReturnString())
262 assert_equal(123, ReturnNumber())
Bram Moolenaar09f28f42020-02-20 23:08:34 +0100263 assert_fails('call ReturnGlobal()', 'E1029: Expected number but got string')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100264enddef
265
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200266let s:nothing = 0
267def ReturnNothing()
268 s:nothing = 1
269 if true
270 return
271 endif
272 s:nothing = 2
273enddef
274
275def Test_return_nothing()
276 ReturnNothing()
277 assert_equal(1, s:nothing)
278enddef
279
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100280func Increment()
281 let g:counter += 1
282endfunc
283
284def Test_call_ufunc_count()
285 g:counter = 1
286 Increment()
287 Increment()
288 Increment()
289 " works with and without :call
290 assert_equal(4, g:counter)
Bram Moolenaarb283a8a2020-02-02 22:24:04 +0100291 call assert_equal(4, g:counter)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100292 unlet g:counter
293enddef
294
295def MyVarargs(arg: string, ...rest: list<string>): string
296 let res = arg
297 for s in rest
298 res ..= ',' .. s
299 endfor
300 return res
301enddef
302
303def Test_call_varargs()
304 assert_equal('one', MyVarargs('one'))
305 assert_equal('one,two', MyVarargs('one', 'two'))
306 assert_equal('one,two,three', MyVarargs('one', 'two', 'three'))
307enddef
308
Bram Moolenaar170fcfc2020-02-06 17:51:35 +0100309def MyDefaultArgs(name = 'string'): string
310 return name
311enddef
312
313def Test_call_default_args()
314 assert_equal('string', MyDefaultArgs())
315 assert_equal('one', MyDefaultArgs('one'))
316 assert_fails('call MyDefaultArgs("one", "two")', 'E118:')
317enddef
318
319func Test_call_default_args_from_func()
320 call assert_equal('string', MyDefaultArgs())
321 call assert_equal('one', MyDefaultArgs('one'))
322 call assert_fails('call MyDefaultArgs("one", "two")', 'E118:')
323endfunc
324
Bram Moolenaarb35efa52020-02-26 20:15:18 +0100325func TakesOneArg(arg)
326 echo a:arg
327endfunc
328
Bram Moolenaarbd5da372020-03-31 23:13:10 +0200329def Test_call_wrong_args()
Bram Moolenaarb35efa52020-02-26 20:15:18 +0100330 call CheckDefFailure(['TakesOneArg()'], 'E119:')
331 call CheckDefFailure(['TakesOneArg(11, 22)'], 'E118:')
Bram Moolenaarbd5da372020-03-31 23:13:10 +0200332 call CheckDefFailure(['bufnr(xxx)'], 'E1001:')
Bram Moolenaarb35efa52020-02-26 20:15:18 +0100333enddef
334
Bram Moolenaar170fcfc2020-02-06 17:51:35 +0100335" Default arg and varargs
336def MyDefVarargs(one: string, two = 'foo', ...rest: list<string>): string
337 let res = one .. ',' .. two
338 for s in rest
339 res ..= ',' .. s
340 endfor
341 return res
342enddef
343
344def Test_call_def_varargs()
345 call assert_fails('call MyDefVarargs()', 'E119:')
346 assert_equal('one,foo', MyDefVarargs('one'))
347 assert_equal('one,two', MyDefVarargs('one', 'two'))
348 assert_equal('one,two,three', MyDefVarargs('one', 'two', 'three'))
349enddef
350
Bram Moolenaar42a480b2020-02-29 23:23:47 +0100351def Test_using_var_as_arg()
352 call writefile(['def Func(x: number)', 'let x = 234', 'enddef'], 'Xdef')
353 call assert_fails('so Xdef', 'E1006:')
354 call delete('Xdef')
355enddef
356
Bram Moolenaarb35efa52020-02-26 20:15:18 +0100357def Test_call_func_defined_later()
358 call assert_equal('one', DefinedLater('one'))
359 call assert_fails('call NotDefined("one")', 'E117:')
360enddef
Bram Moolenaar170fcfc2020-02-06 17:51:35 +0100361
Bram Moolenaarb35efa52020-02-26 20:15:18 +0100362func DefinedLater(arg)
Bram Moolenaar26e117e2020-02-04 21:24:15 +0100363 return a:arg
364endfunc
365
Bram Moolenaar7eeefd42020-02-26 21:24:23 +0100366def FuncWithForwardCall()
367 return DefinedEvenLater("yes")
368enddef
369
370def DefinedEvenLater(arg: string): string
371 return arg
372enddef
373
374def Test_error_in_nested_function()
375 " Error in called function requires unwinding the call stack.
376 assert_fails('call FuncWithForwardCall()', 'E1029')
377enddef
378
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100379def Test_return_type_wrong()
Bram Moolenaar978d1702020-01-26 17:38:12 +0100380 CheckScriptFailure(['def Func(): number', 'return "a"', 'enddef'], 'expected number but got string')
381 CheckScriptFailure(['def Func(): string', 'return 1', 'enddef'], 'expected string but got number')
382 CheckScriptFailure(['def Func(): void', 'return "a"', 'enddef'], 'expected void but got string')
383 CheckScriptFailure(['def Func()', 'return "a"', 'enddef'], 'expected void but got string')
Bram Moolenaarcf3f8bf2020-03-26 13:15:42 +0100384
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200385 CheckScriptFailure(['def Func(): number', 'return', 'enddef'], 'E1003:')
386
Bram Moolenaarcf3f8bf2020-03-26 13:15:42 +0100387 CheckScriptFailure(['def Func(): list', 'return []', 'enddef'], 'E1008:')
388 CheckScriptFailure(['def Func(): dict', 'return {}', 'enddef'], 'E1008:')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100389enddef
390
Bram Moolenaarbfe12042020-02-04 21:54:07 +0100391def Test_arg_type_wrong()
392 CheckScriptFailure(['def Func3(items: list)', 'echo "a"', 'enddef'], 'E1008: Missing <type>')
393enddef
394
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100395def Test_try_catch()
396 let l = []
397 try
398 add(l, '1')
399 throw 'wrong'
400 add(l, '2')
401 catch
402 add(l, v:exception)
403 finally
404 add(l, '3')
405 endtry
406 assert_equal(['1', 'wrong', '3'], l)
407enddef
408
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100409def ThrowFromDef()
410 throw 'getout'
411enddef
412
413func CatchInFunc()
414 try
415 call ThrowFromDef()
416 catch
417 let g:thrown_func = v:exception
418 endtry
419endfunc
420
421def CatchInDef()
422 try
423 ThrowFromDef()
424 catch
425 g:thrown_def = v:exception
426 endtry
427enddef
428
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100429def ReturnFinally(): string
430 try
431 return 'intry'
432 finally
433 g:in_finally = 'finally'
434 endtry
435 return 'end'
436enddef
437
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100438def Test_try_catch_nested()
439 CatchInFunc()
440 assert_equal('getout', g:thrown_func)
441
442 CatchInDef()
443 assert_equal('getout', g:thrown_def)
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100444
445 assert_equal('intry', ReturnFinally())
446 assert_equal('finally', g:in_finally)
447enddef
448
449def Test_try_catch_match()
450 let seq = 'a'
451 try
452 throw 'something'
453 catch /nothing/
454 seq ..= 'x'
455 catch /some/
456 seq ..= 'b'
457 catch /asdf/
458 seq ..= 'x'
459 finally
460 seq ..= 'c'
461 endtry
462 assert_equal('abc', seq)
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100463enddef
464
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100465let s:export_script_lines =<< trim END
466 vim9script
467 let name: string = 'bob'
468 def Concat(arg: string): string
469 return name .. arg
470 enddef
471 let g:result = Concat('bie')
472 let g:localname = name
473
474 export const CONST = 1234
475 export let exported = 9876
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100476 export let exp_name = 'John'
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100477 export def Exported(): string
478 return 'Exported'
479 enddef
480END
481
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100482def Test_vim9_import_export()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100483 let import_script_lines =<< trim END
484 vim9script
485 import {exported, Exported} from './Xexport.vim'
486 g:imported = exported
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100487 exported += 3
488 g:imported_added = exported
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100489 g:imported_func = Exported()
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100490
491 import {exp_name} from './Xexport.vim'
492 g:imported_name = exp_name
493 exp_name ..= ' Doe'
494 g:imported_name_appended = exp_name
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100495 g:imported_later = exported
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100496 END
497
498 writefile(import_script_lines, 'Ximport.vim')
499 writefile(s:export_script_lines, 'Xexport.vim')
500
501 source Ximport.vim
502
503 assert_equal('bobbie', g:result)
504 assert_equal('bob', g:localname)
505 assert_equal(9876, g:imported)
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100506 assert_equal(9879, g:imported_added)
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100507 assert_equal(9879, g:imported_later)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100508 assert_equal('Exported', g:imported_func)
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100509 assert_equal('John', g:imported_name)
510 assert_equal('John Doe', g:imported_name_appended)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100511 assert_false(exists('g:name'))
512
513 unlet g:result
514 unlet g:localname
515 unlet g:imported
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100516 unlet g:imported_added
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100517 unlet g:imported_later
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100518 unlet g:imported_func
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100519 unlet g:imported_name g:imported_name_appended
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100520 delete('Ximport.vim')
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100521
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100522 let import_in_def_lines =<< trim END
523 vim9script
524 def ImportInDef()
525 import exported from './Xexport.vim'
526 g:imported = exported
527 exported += 7
528 g:imported_added = exported
529 enddef
530 ImportInDef()
531 END
532 writefile(import_in_def_lines, 'Ximport2.vim')
533 source Ximport2.vim
534 " TODO: this should be 9879
535 assert_equal(9876, g:imported)
536 assert_equal(9883, g:imported_added)
537 unlet g:imported
538 unlet g:imported_added
539 delete('Ximport2.vim')
540
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100541 let import_star_as_lines =<< trim END
542 vim9script
543 import * as Export from './Xexport.vim'
544 def UseExport()
545 g:imported = Export.exported
546 enddef
547 UseExport()
548 END
549 writefile(import_star_as_lines, 'Ximport.vim')
550 source Ximport.vim
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100551 assert_equal(9883, g:imported)
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100552
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100553 let import_star_as_lines_no_dot =<< trim END
554 vim9script
555 import * as Export from './Xexport.vim'
556 def Func()
557 let dummy = 1
558 let imported = Export + dummy
559 enddef
560 END
561 writefile(import_star_as_lines_no_dot, 'Ximport.vim')
562 assert_fails('source Ximport.vim', 'E1060:')
563
564 let import_star_as_lines_dot_space =<< trim END
565 vim9script
566 import * as Export from './Xexport.vim'
567 def Func()
568 let imported = Export . exported
569 enddef
570 END
571 writefile(import_star_as_lines_dot_space, 'Ximport.vim')
572 assert_fails('source Ximport.vim', 'E1074:')
573
574 let import_star_as_lines_missing_name =<< trim END
575 vim9script
576 import * as Export from './Xexport.vim'
577 def Func()
578 let imported = Export.
579 enddef
580 END
581 writefile(import_star_as_lines_missing_name, 'Ximport.vim')
582 assert_fails('source Ximport.vim', 'E1048:')
583
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100584 let import_star_lines =<< trim END
585 vim9script
586 import * from './Xexport.vim'
587 g:imported = exported
588 END
589 writefile(import_star_lines, 'Ximport.vim')
590 assert_fails('source Ximport.vim', 'E1045:')
591
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +0100592 " try to import something that exists but is not exported
593 let import_not_exported_lines =<< trim END
594 vim9script
595 import name from './Xexport.vim'
596 END
597 writefile(import_not_exported_lines, 'Ximport.vim')
598 assert_fails('source Ximport.vim', 'E1049:')
599
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100600 " try to import something that is already defined
601 let import_already_defined =<< trim END
602 vim9script
603 let exported = 'something'
604 import exported from './Xexport.vim'
605 END
606 writefile(import_already_defined, 'Ximport.vim')
607 assert_fails('source Ximport.vim', 'E1073:')
608
609 " try to import something that is already defined
610 import_already_defined =<< trim END
611 vim9script
612 let exported = 'something'
613 import * as exported from './Xexport.vim'
614 END
615 writefile(import_already_defined, 'Ximport.vim')
616 assert_fails('source Ximport.vim', 'E1073:')
617
618 " try to import something that is already defined
619 import_already_defined =<< trim END
620 vim9script
621 let exported = 'something'
622 import {exported} from './Xexport.vim'
623 END
624 writefile(import_already_defined, 'Ximport.vim')
625 assert_fails('source Ximport.vim', 'E1073:')
626
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +0100627 " import a very long name, requires making a copy
628 let import_long_name_lines =<< trim END
629 vim9script
630 import name012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 from './Xexport.vim'
631 END
632 writefile(import_long_name_lines, 'Ximport.vim')
633 assert_fails('source Ximport.vim', 'E1048:')
634
635 let import_no_from_lines =<< trim END
636 vim9script
637 import name './Xexport.vim'
638 END
639 writefile(import_no_from_lines, 'Ximport.vim')
640 assert_fails('source Ximport.vim', 'E1070:')
641
642 let import_invalid_string_lines =<< trim END
643 vim9script
644 import name from Xexport.vim
645 END
646 writefile(import_invalid_string_lines, 'Ximport.vim')
647 assert_fails('source Ximport.vim', 'E1071:')
648
649 let import_wrong_name_lines =<< trim END
650 vim9script
651 import name from './XnoExport.vim'
652 END
653 writefile(import_wrong_name_lines, 'Ximport.vim')
654 assert_fails('source Ximport.vim', 'E1053:')
655
656 let import_missing_comma_lines =<< trim END
657 vim9script
658 import {exported name} from './Xexport.vim'
659 END
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100660 writefile(import_missing_comma_lines, 'Ximport3.vim')
661 assert_fails('source Ximport3.vim', 'E1046:')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +0100662
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100663 delete('Ximport.vim')
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100664 delete('Ximport3.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100665 delete('Xexport.vim')
666
Bram Moolenaar750802b2020-02-23 18:08:33 +0100667 " Check that in a Vim9 script 'cpo' is set to the Vim default.
668 set cpo&vi
669 let cpo_before = &cpo
670 let lines =<< trim END
671 vim9script
672 g:cpo_in_vim9script = &cpo
673 END
674 writefile(lines, 'Xvim9_script')
675 source Xvim9_script
676 assert_equal(cpo_before, &cpo)
677 set cpo&vim
678 assert_equal(&cpo, g:cpo_in_vim9script)
679 delete('Xvim9_script')
680enddef
681
682def Test_vim9script_fails()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100683 CheckScriptFailure(['scriptversion 2', 'vim9script'], 'E1039:')
684 CheckScriptFailure(['vim9script', 'scriptversion 2'], 'E1040:')
Bram Moolenaar750802b2020-02-23 18:08:33 +0100685 CheckScriptFailure(['export let some = 123'], 'E1042:')
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100686 CheckScriptFailure(['import some from "./Xexport.vim"'], 'E1042:')
Bram Moolenaar750802b2020-02-23 18:08:33 +0100687 CheckScriptFailure(['vim9script', 'export let g:some'], 'E1044:')
688 CheckScriptFailure(['vim9script', 'export echo 134'], 'E1043:')
689
690 assert_fails('vim9script', 'E1038')
691 assert_fails('export something', 'E1042')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100692enddef
693
694def Test_vim9script_call()
695 let lines =<< trim END
696 vim9script
697 let var = ''
698 def MyFunc(arg: string)
699 var = arg
700 enddef
701 MyFunc('foobar')
702 assert_equal('foobar', var)
703
704 let str = 'barfoo'
705 str->MyFunc()
706 assert_equal('barfoo', var)
707
708 let g:value = 'value'
709 g:value->MyFunc()
710 assert_equal('value', var)
711
712 let listvar = []
713 def ListFunc(arg: list<number>)
714 listvar = arg
715 enddef
716 [1, 2, 3]->ListFunc()
717 assert_equal([1, 2, 3], listvar)
718
719 let dictvar = {}
720 def DictFunc(arg: dict<number>)
721 dictvar = arg
722 enddef
723 {'a': 1, 'b': 2}->DictFunc()
724 assert_equal(#{a: 1, b: 2}, dictvar)
Bram Moolenaar33fa29c2020-03-28 19:41:33 +0100725 def CompiledDict()
726 {'a': 3, 'b': 4}->DictFunc()
727 enddef
728 CompiledDict()
729 assert_equal(#{a: 3, b: 4}, dictvar)
730
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100731 #{a: 3, b: 4}->DictFunc()
732 assert_equal(#{a: 3, b: 4}, dictvar)
Bram Moolenaar0c6ceaf2020-02-22 18:36:32 +0100733
734 ('text')->MyFunc()
735 assert_equal('text', var)
736 ("some")->MyFunc()
737 assert_equal('some', var)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100738 END
739 writefile(lines, 'Xcall.vim')
740 source Xcall.vim
741 delete('Xcall.vim')
742enddef
743
744def Test_vim9script_call_fail_decl()
745 let lines =<< trim END
746 vim9script
747 let var = ''
748 def MyFunc(arg: string)
749 let var = 123
750 enddef
751 END
752 writefile(lines, 'Xcall_decl.vim')
753 assert_fails('source Xcall_decl.vim', 'E1054:')
754 delete('Xcall_decl.vim')
755enddef
756
757def Test_vim9script_call_fail_const()
758 let lines =<< trim END
759 vim9script
760 const var = ''
761 def MyFunc(arg: string)
762 var = 'asdf'
763 enddef
764 END
765 writefile(lines, 'Xcall_const.vim')
766 assert_fails('source Xcall_const.vim', 'E46:')
767 delete('Xcall_const.vim')
768enddef
769
770def Test_vim9script_reload()
771 let lines =<< trim END
772 vim9script
773 const var = ''
774 let valone = 1234
775 def MyFunc(arg: string)
776 valone = 5678
777 enddef
778 END
779 let morelines =<< trim END
780 let valtwo = 222
781 export def GetValtwo(): number
782 return valtwo
783 enddef
784 END
785 writefile(lines + morelines, 'Xreload.vim')
786 source Xreload.vim
787 source Xreload.vim
788 source Xreload.vim
789
790 let testlines =<< trim END
791 vim9script
792 def TheFunc()
793 import GetValtwo from './Xreload.vim'
794 assert_equal(222, GetValtwo())
795 enddef
796 TheFunc()
797 END
798 writefile(testlines, 'Ximport.vim')
799 source Ximport.vim
800
801 " test that when not using "morelines" valtwo is still defined
802 " need to source Xreload.vim again, import doesn't reload a script
803 writefile(lines, 'Xreload.vim')
804 source Xreload.vim
805 source Ximport.vim
806
807 " cannot declare a var twice
808 lines =<< trim END
809 vim9script
810 let valone = 1234
811 let valone = 5678
812 END
813 writefile(lines, 'Xreload.vim')
814 assert_fails('source Xreload.vim', 'E1041:')
815
816 delete('Xreload.vim')
817 delete('Ximport.vim')
818enddef
819
820def Test_import_absolute()
821 let import_lines = [
822 \ 'vim9script',
823 \ 'import exported from "' .. escape(getcwd(), '\') .. '/Xexport_abs.vim"',
Bram Moolenaarb283a8a2020-02-02 22:24:04 +0100824 \ 'def UseExported()',
825 \ ' g:imported_abs = exported',
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +0100826 \ ' exported = 8888',
827 \ ' g:imported_after = exported',
Bram Moolenaarb283a8a2020-02-02 22:24:04 +0100828 \ 'enddef',
829 \ 'UseExported()',
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +0100830 \ 'g:import_disassembled = execute("disass UseExported")',
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100831 \ ]
832 writefile(import_lines, 'Ximport_abs.vim')
833 writefile(s:export_script_lines, 'Xexport_abs.vim')
834
835 source Ximport_abs.vim
836
837 assert_equal(9876, g:imported_abs)
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +0100838 assert_equal(8888, g:imported_after)
Bram Moolenaarb283a8a2020-02-02 22:24:04 +0100839 assert_match('<SNR>\d\+_UseExported.*'
840 \ .. 'g:imported_abs = exported.*'
841 \ .. '0 LOADSCRIPT exported from .*Xexport_abs.vim.*'
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +0100842 \ .. '1 STOREG g:imported_abs.*'
843 \ .. 'exported = 8888.*'
844 \ .. '3 STORESCRIPT exported in .*Xexport_abs.vim.*'
845 \ .. 'g:imported_after = exported.*'
846 \ .. '4 LOADSCRIPT exported from .*Xexport_abs.vim.*'
847 \ .. '5 STOREG g:imported_after.*'
848 \, g:import_disassembled)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100849 unlet g:imported_abs
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +0100850 unlet g:import_disassembled
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100851
852 delete('Ximport_abs.vim')
853 delete('Xexport_abs.vim')
854enddef
855
856def Test_import_rtp()
857 let import_lines = [
858 \ 'vim9script',
859 \ 'import exported from "Xexport_rtp.vim"',
860 \ 'g:imported_rtp = exported',
861 \ ]
862 writefile(import_lines, 'Ximport_rtp.vim')
863 mkdir('import')
864 writefile(s:export_script_lines, 'import/Xexport_rtp.vim')
865
866 let save_rtp = &rtp
867 &rtp = getcwd()
868 source Ximport_rtp.vim
869 &rtp = save_rtp
870
871 assert_equal(9876, g:imported_rtp)
872 unlet g:imported_rtp
873
874 delete('Ximport_rtp.vim')
875 delete('import/Xexport_rtp.vim')
876 delete('import', 'd')
877enddef
878
879def Test_fixed_size_list()
880 " will be allocated as one piece of memory, check that changes work
881 let l = [1, 2, 3, 4]
882 l->remove(0)
883 l->add(5)
884 l->insert(99, 1)
Bram Moolenaar0f18b6d2020-02-02 17:22:27 +0100885 assert_equal([2, 99, 3, 4, 5], l)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100886enddef
887
Bram Moolenaar673660a2020-01-26 16:50:05 +0100888" Test that inside :function a Python function can be defined, :def is not
889" recognized.
890func Test_function_python()
891 CheckFeature python3
892 let py = 'python3'
893 execute py "<< EOF"
894def do_something():
895 return 1
896EOF
897endfunc
898
Bram Moolenaar158906c2020-02-06 20:39:45 +0100899def IfElse(what: number): string
900 let res = ''
901 if what == 1
902 res = "one"
903 elseif what == 2
904 res = "two"
Bram Moolenaara259d8d2020-01-31 20:10:50 +0100905 else
Bram Moolenaar158906c2020-02-06 20:39:45 +0100906 res = "three"
Bram Moolenaara259d8d2020-01-31 20:10:50 +0100907 endif
Bram Moolenaar158906c2020-02-06 20:39:45 +0100908 return res
Bram Moolenaara259d8d2020-01-31 20:10:50 +0100909enddef
910
Bram Moolenaar158906c2020-02-06 20:39:45 +0100911def Test_if_elseif_else()
912 assert_equal('one', IfElse(1))
913 assert_equal('two', IfElse(2))
914 assert_equal('three', IfElse(3))
Bram Moolenaar0f18b6d2020-02-02 17:22:27 +0100915enddef
916
Bram Moolenaar6d69bf62020-03-03 19:02:12 +0100917let g:bool_true = v:true
918let g:bool_false = v:false
919
920def Test_if_const_expr()
921 let res = false
922 if true ? true : false
923 res = true
924 endif
925 assert_equal(true, res)
926
927 res = false
928 if g:bool_true ? true : false
929 res = true
930 endif
931 assert_equal(true, res)
932
933 res = false
934 if true ? g:bool_true : false
935 res = true
936 endif
937 assert_equal(true, res)
938
939 res = false
940 if true ? true : g:bool_false
941 res = true
942 endif
943 assert_equal(true, res)
944
945 res = false
946 if true ? false : true
947 res = true
948 endif
949 assert_equal(false, res)
950
951 res = false
952 if false ? false : true
953 res = true
954 endif
955 assert_equal(true, res)
956
957 res = false
958 if false ? true : false
959 res = true
960 endif
961 assert_equal(false, res)
962
963 res = false
964 if true && true
965 res = true
966 endif
967 assert_equal(true, res)
968
969 res = false
970 if true && false
971 res = true
972 endif
973 assert_equal(false, res)
974
975 res = false
976 if g:bool_true && false
977 res = true
978 endif
979 assert_equal(false, res)
980
981 res = false
982 if true && g:bool_false
983 res = true
984 endif
985 assert_equal(false, res)
986
987 res = false
988 if false && false
989 res = true
990 endif
991 assert_equal(false, res)
992
993 res = false
994 if true || false
995 res = true
996 endif
997 assert_equal(true, res)
998
999 res = false
1000 if g:bool_true || false
1001 res = true
1002 endif
1003 assert_equal(true, res)
1004
1005 res = false
1006 if true || g:bool_false
1007 res = true
1008 endif
1009 assert_equal(true, res)
1010
1011 res = false
1012 if false || false
1013 res = true
1014 endif
1015 assert_equal(false, res)
1016
1017enddef
1018
Bram Moolenaar63ce4842020-02-19 15:46:48 +01001019def Test_delfunc()
1020 let lines =<< trim END
1021 vim9script
1022 def GoneSoon()
1023 echo 'hello'
1024 enddef
1025
1026 def CallGoneSoon()
1027 GoneSoon()
1028 enddef
1029
1030 delfunc GoneSoon
1031 CallGoneSoon()
1032 END
1033 writefile(lines, 'XToDelFunc')
1034 assert_fails('so XToDelFunc', 'E933')
1035 assert_fails('so XToDelFunc', 'E933')
1036
1037 delete('XToDelFunc')
1038enddef
1039
Bram Moolenaarad39c092020-02-26 18:23:43 +01001040def Test_execute_cmd()
1041 new
1042 setline(1, 'default')
1043 execute 'call setline(1, "execute-string")'
1044 assert_equal('execute-string', getline(1))
1045 let cmd1 = 'call setline(1,'
1046 let cmd2 = '"execute-var")'
1047 execute cmd1 cmd2
1048 assert_equal('execute-var', getline(1))
1049 execute cmd1 cmd2 '|call setline(1, "execute-var-string")'
1050 assert_equal('execute-var-string', getline(1))
1051 let cmd_first = 'call '
1052 let cmd_last = 'setline(1, "execute-var-var")'
1053 execute cmd_first .. cmd_last
1054 assert_equal('execute-var-var', getline(1))
1055 bwipe!
1056enddef
1057
1058def Test_echo_cmd()
1059 echo 'something'
1060 assert_match('^something$', Screenline(&lines))
1061
1062 let str1 = 'some'
1063 let str2 = 'more'
1064 echo str1 str2
1065 assert_match('^some more$', Screenline(&lines))
1066enddef
1067
Bram Moolenaar41fe0612020-03-01 16:22:40 +01001068def Test_for_outside_of_function()
1069 let lines =<< trim END
1070 vim9script
1071 new
1072 for var in range(0, 3)
1073 append(line('$'), var)
1074 endfor
1075 assert_equal(['', '0', '1', '2', '3'], getline(1, '$'))
1076 bwipe!
1077 END
1078 writefile(lines, 'Xvim9for.vim')
1079 source Xvim9for.vim
1080 delete('Xvim9for.vim')
1081enddef
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001082
Bram Moolenaard0df1aa2020-03-04 21:50:46 +01001083def Test_while_loop()
1084 let result = ''
1085 let cnt = 0
1086 while cnt < 555
1087 if cnt == 3
1088 break
1089 endif
1090 cnt += 1
1091 if cnt == 2
1092 continue
1093 endif
1094 result ..= cnt .. '_'
1095 endwhile
1096 assert_equal('1_3_', result)
1097enddef
1098
Bram Moolenaarbd5da372020-03-31 23:13:10 +02001099def Test_for_loop_fails()
1100 call CheckDefFailure(['for # in range(5)'], 'E690:')
1101 call CheckDefFailure(['for i In range(5)'], 'E690:')
1102 call CheckDefFailure(['let x = 5', 'for x in range(5)'], 'E1023:')
1103 call CheckScriptFailure(['def Func(arg)', 'for arg in range(5)', 'enddef'], 'E1006:')
1104 call CheckDefFailure(['for i in "text"'], 'E1024:')
1105enddef
1106
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01001107def Test_interrupt_loop()
Bram Moolenaar97acfc72020-03-22 13:44:28 +01001108 let caught = false
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01001109 let x = 0
Bram Moolenaar97acfc72020-03-22 13:44:28 +01001110 try
1111 while 1
1112 x += 1
1113 if x == 100
1114 feedkeys("\<C-C>", 'Lt')
1115 endif
1116 endwhile
1117 catch
1118 caught = true
1119 assert_equal(100, x)
1120 endtry
1121 assert_true(caught, 'should have caught an exception')
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01001122enddef
Bram Moolenaar20431c92020-03-20 18:39:46 +01001123
Bram Moolenaard0df1aa2020-03-04 21:50:46 +01001124def Test_substitute_cmd()
1125 new
1126 setline(1, 'something')
1127 :substitute(some(other(
1128 assert_equal('otherthing', getline(1))
1129 bwipe!
1130
1131 " also when the context is Vim9 script
1132 let lines =<< trim END
1133 vim9script
1134 new
1135 setline(1, 'something')
1136 :substitute(some(other(
1137 assert_equal('otherthing', getline(1))
1138 bwipe!
1139 END
1140 writefile(lines, 'Xvim9lines')
1141 source Xvim9lines
1142
1143 delete('Xvim9lines')
1144enddef
1145
Bram Moolenaar20431c92020-03-20 18:39:46 +01001146def Test_redef_failure()
1147 call writefile(['def Func0(): string', 'return "Func0"', 'enddef'], 'Xdef')
1148 so Xdef
1149 call writefile(['def Func1(): string', 'return "Func1"', 'enddef'], 'Xdef')
1150 so Xdef
1151 call writefile(['def! Func0(): string', 'enddef'], 'Xdef')
1152 call assert_fails('so Xdef', 'E1027:')
1153 call writefile(['def Func2(): string', 'return "Func2"', 'enddef'], 'Xdef')
1154 so Xdef
1155 call delete('Xdef')
1156
1157 call assert_equal(0, Func0())
1158 call assert_equal('Func1', Func1())
1159 call assert_equal('Func2', Func2())
1160
1161 delfunc! Func0
1162 delfunc! Func1
1163 delfunc! Func2
1164enddef
1165
Bram Moolenaar7d941ee2020-03-26 14:11:58 +01001166" Test for internal functions returning different types
1167func Test_InternalFuncRetType()
1168 let lines =<< trim END
1169 def RetFloat(): float
1170 return ceil(1.456)
1171 enddef
1172
1173 def RetListAny(): list<any>
1174 return items({'k' : 'v'})
1175 enddef
1176
1177 def RetListString(): list<string>
1178 return split('a:b:c', ':')
1179 enddef
1180
1181 def RetListDictAny(): list<dict<any>>
1182 return getbufinfo()
1183 enddef
1184
1185 def RetDictNumber(): dict<number>
1186 return wordcount()
1187 enddef
1188
1189 def RetDictString(): dict<string>
1190 return environ()
1191 enddef
1192 END
1193 call writefile(lines, 'Xscript')
1194 source Xscript
1195
1196 call assert_equal(2.0, RetFloat())
1197 call assert_equal([['k', 'v']], RetListAny())
1198 call assert_equal(['a', 'b', 'c'], RetListString())
1199 call assert_notequal([], RetListDictAny())
1200 call assert_notequal({}, RetDictNumber())
1201 call assert_notequal({}, RetDictString())
1202 call delete('Xscript')
1203endfunc
1204
1205" Test for passing too many or too few arguments to internal functions
1206func Test_internalfunc_arg_error()
1207 let l =<< trim END
1208 def! FArgErr(): float
1209 return ceil(1.1, 2)
1210 enddef
1211 END
1212 call writefile(l, 'Xinvalidarg')
1213 call assert_fails('so Xinvalidarg', 'E118:')
1214 let l =<< trim END
1215 def! FArgErr(): float
1216 return ceil()
1217 enddef
1218 END
1219 call writefile(l, 'Xinvalidarg')
1220 call assert_fails('so Xinvalidarg', 'E119:')
1221 call delete('Xinvalidarg')
1222endfunc
1223
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001224" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker