blob: d93ea6a06c28a79c355982a6066b53db52f05917 [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)
Bram Moolenaar80c34ca2020-04-01 23:05:18 +0200103 &ts -= 3
104 assert_equal(5, &ts)
105 &ts *= 2
106 assert_equal(10, &ts)
107 &ts /= 3
108 assert_equal(3, &ts)
109 set ts=10
110 &ts %= 4
111 assert_equal(2, &ts)
Bram Moolenaara8c17702020-04-01 21:17:24 +0200112 call CheckDefFailure(['&notex += 3'], 'E113:')
113 call CheckDefFailure(['&ts ..= "xxx"'], 'E1019:')
114 call CheckDefFailure(['&path += 3'], 'E1013:')
Bram Moolenaar80c34ca2020-04-01 23:05:18 +0200115 &ts = 8
Bram Moolenaara8c17702020-04-01 21:17:24 +0200116
117 g:inc_counter += 1
118 assert_equal(2, g:inc_counter)
119
120 $SOME_ENV_VAR ..= 'more'
121 assert_equal('somemore', $SOME_ENV_VAR)
122 call CheckDefFailure(['$SOME_ENV_VAR += "more"'], 'E1013:')
123 call CheckDefFailure(['$SOME_ENV_VAR += 123'], 'E1013:')
124
125 @a = 'areg'
126 @a ..= 'add'
127 assert_equal('aregadd', @a)
128 call CheckDefFailure(['@a += "more"'], 'E1013:')
129 call CheckDefFailure(['@a += 123'], 'E1013:')
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200130
131 v:errmsg = 'none'
132 v:errmsg ..= 'again'
133 assert_equal('noneagain', v:errmsg)
134 call CheckDefFailure(['v:errmsg += "more"'], 'E1013:')
135 call CheckDefFailure(['v:errmsg += 123'], 'E1013:')
136
137 " Test default values.
138 let thebool: bool
139 assert_equal(v:false, thebool)
140
141 let thenumber: number
142 assert_equal(0, thenumber)
143
144 if has('float')
145 let thefloat: float
146 assert_equal(0.0, thefloat)
147 endif
148
149 let thestring: string
150 assert_equal('', thestring)
151
152 let theblob: blob
153 assert_equal(0z, theblob)
154
155 let thefunc: func
156 assert_equal(test_null_function(), thefunc)
157
158 let thepartial: partial
159 assert_equal(test_null_partial(), thepartial)
160
161 let thelist: list<any>
162 assert_equal([], thelist)
163
164 let thedict: dict<any>
165 assert_equal({}, thedict)
166
Bram Moolenaar2c869de2020-04-02 19:12:08 +0200167 if has('channel')
168 let thejob: job
169 assert_equal(test_null_job(), thejob)
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200170
Bram Moolenaar2c869de2020-04-02 19:12:08 +0200171 let thechannel: channel
172 assert_equal(test_null_channel(), thechannel)
173 endif
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100174enddef
175
176func Test_assignment_failure()
177 call CheckDefFailure(['let var=234'], 'E1004:')
178 call CheckDefFailure(['let var =234'], 'E1004:')
179 call CheckDefFailure(['let var= 234'], 'E1004:')
180
181 call CheckDefFailure(['let true = 1'], 'E1034:')
182 call CheckDefFailure(['let false = 1'], 'E1034:')
183
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200184 call CheckDefFailure(['let [a; b; c] = g:list'], 'E452:')
185
Bram Moolenaare69f6d02020-04-01 22:11:01 +0200186 call CheckDefFailure(['let somevar'], "E1022:")
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200187 call CheckDefFailure(['let &option'], 'E1052:')
188 call CheckDefFailure(['&g:option = 5'], 'E113:')
189
190 call CheckDefFailure(['let $VAR = 5'], 'E1065:')
191
192 call CheckDefFailure(['let @~ = 5'], 'E354:')
193 call CheckDefFailure(['let @a = 5'], 'E1066:')
194
195 call CheckDefFailure(['let g:var = 5'], 'E1016:')
196
197 call CheckDefFailure(['let anr = 4', 'anr ..= "text"'], 'E1019:')
198 call CheckDefFailure(['let xnr += 4'], 'E1020:')
199
Bram Moolenaar33fa29c2020-03-28 19:41:33 +0100200 call CheckScriptFailure(['vim9script', 'def Func()', 'let dummy = s:notfound', 'enddef'], 'E1050:')
201
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100202 call CheckDefFailure(['let var: list<string> = [123]'], 'expected list<string> but got list<number>')
203 call CheckDefFailure(['let var: list<number> = ["xx"]'], 'expected list<number> but got list<string>')
204
205 call CheckDefFailure(['let var: dict<string> = #{key: 123}'], 'expected dict<string> but got dict<number>')
206 call CheckDefFailure(['let var: dict<number> = #{key: "xx"}'], 'expected dict<number> but got dict<string>')
207
208 call CheckDefFailure(['let var = feedkeys("0")'], 'E1031:')
209 call CheckDefFailure(['let var: number = feedkeys("0")'], 'expected number but got void')
Bram Moolenaar42a480b2020-02-29 23:23:47 +0100210
211 call CheckDefFailure(['let var: dict <number>'], 'E1007:')
212 call CheckDefFailure(['let var: dict<number'], 'E1009:')
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100213endfunc
214
215func Test_wrong_type()
216 call CheckDefFailure(['let var: list<nothing>'], 'E1010:')
217 call CheckDefFailure(['let var: list<list<nothing>>'], 'E1010:')
218 call CheckDefFailure(['let var: dict<nothing>'], 'E1010:')
219 call CheckDefFailure(['let var: dict<dict<nothing>>'], 'E1010:')
220
221 call CheckDefFailure(['let var: dict<number'], 'E1009:')
222 call CheckDefFailure(['let var: dict<list<number>'], 'E1009:')
Bram Moolenaar42a480b2020-02-29 23:23:47 +0100223
224 call CheckDefFailure(['let var: ally'], 'E1010:')
225 call CheckDefFailure(['let var: bram'], 'E1010:')
226 call CheckDefFailure(['let var: cathy'], 'E1010:')
227 call CheckDefFailure(['let var: dom'], 'E1010:')
228 call CheckDefFailure(['let var: freddy'], 'E1010:')
229 call CheckDefFailure(['let var: john'], 'E1010:')
230 call CheckDefFailure(['let var: larry'], 'E1010:')
231 call CheckDefFailure(['let var: ned'], 'E1010:')
232 call CheckDefFailure(['let var: pam'], 'E1010:')
233 call CheckDefFailure(['let var: sam'], 'E1010:')
234 call CheckDefFailure(['let var: vim'], 'E1010:')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100235endfunc
236
237func Test_const()
238 call CheckDefFailure(['const var = 234', 'var = 99'], 'E1018:')
239 call CheckDefFailure(['const one = 234', 'let one = 99'], 'E1017:')
240 call CheckDefFailure(['const two'], 'E1021:')
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200241 call CheckDefFailure(['const &option'], 'E996:')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100242endfunc
243
244def Test_block()
245 let outer = 1
246 {
247 let inner = 2
248 assert_equal(1, outer)
249 assert_equal(2, inner)
250 }
251 assert_equal(1, outer)
252enddef
253
254func Test_block_failure()
255 call CheckDefFailure(['{', 'let inner = 1', '}', 'echo inner'], 'E1001:')
256endfunc
257
258def ReturnString(): string
259 return 'string'
260enddef
261
262def ReturnNumber(): number
263 return 123
264enddef
265
Bram Moolenaar09f28f42020-02-20 23:08:34 +0100266let g:notNumber = 'string'
267
268def ReturnGlobal(): number
269 return g:notNumber
270enddef
271
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200272def Test_return_something()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100273 assert_equal('string', ReturnString())
274 assert_equal(123, ReturnNumber())
Bram Moolenaar09f28f42020-02-20 23:08:34 +0100275 assert_fails('call ReturnGlobal()', 'E1029: Expected number but got string')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100276enddef
277
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200278let s:nothing = 0
279def ReturnNothing()
280 s:nothing = 1
281 if true
282 return
283 endif
284 s:nothing = 2
285enddef
286
287def Test_return_nothing()
288 ReturnNothing()
289 assert_equal(1, s:nothing)
290enddef
291
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100292func Increment()
293 let g:counter += 1
294endfunc
295
296def Test_call_ufunc_count()
297 g:counter = 1
298 Increment()
299 Increment()
300 Increment()
301 " works with and without :call
302 assert_equal(4, g:counter)
Bram Moolenaarb283a8a2020-02-02 22:24:04 +0100303 call assert_equal(4, g:counter)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100304 unlet g:counter
305enddef
306
307def MyVarargs(arg: string, ...rest: list<string>): string
308 let res = arg
309 for s in rest
310 res ..= ',' .. s
311 endfor
312 return res
313enddef
314
315def Test_call_varargs()
316 assert_equal('one', MyVarargs('one'))
317 assert_equal('one,two', MyVarargs('one', 'two'))
318 assert_equal('one,two,three', MyVarargs('one', 'two', 'three'))
319enddef
320
Bram Moolenaar170fcfc2020-02-06 17:51:35 +0100321def MyDefaultArgs(name = 'string'): string
322 return name
323enddef
324
325def Test_call_default_args()
326 assert_equal('string', MyDefaultArgs())
327 assert_equal('one', MyDefaultArgs('one'))
328 assert_fails('call MyDefaultArgs("one", "two")', 'E118:')
329enddef
330
331func Test_call_default_args_from_func()
332 call assert_equal('string', MyDefaultArgs())
333 call assert_equal('one', MyDefaultArgs('one'))
334 call assert_fails('call MyDefaultArgs("one", "two")', 'E118:')
335endfunc
336
Bram Moolenaarb35efa52020-02-26 20:15:18 +0100337func TakesOneArg(arg)
338 echo a:arg
339endfunc
340
Bram Moolenaarbd5da372020-03-31 23:13:10 +0200341def Test_call_wrong_args()
Bram Moolenaarb35efa52020-02-26 20:15:18 +0100342 call CheckDefFailure(['TakesOneArg()'], 'E119:')
343 call CheckDefFailure(['TakesOneArg(11, 22)'], 'E118:')
Bram Moolenaarbd5da372020-03-31 23:13:10 +0200344 call CheckDefFailure(['bufnr(xxx)'], 'E1001:')
Bram Moolenaarb35efa52020-02-26 20:15:18 +0100345enddef
346
Bram Moolenaar170fcfc2020-02-06 17:51:35 +0100347" Default arg and varargs
348def MyDefVarargs(one: string, two = 'foo', ...rest: list<string>): string
349 let res = one .. ',' .. two
350 for s in rest
351 res ..= ',' .. s
352 endfor
353 return res
354enddef
355
356def Test_call_def_varargs()
357 call assert_fails('call MyDefVarargs()', 'E119:')
358 assert_equal('one,foo', MyDefVarargs('one'))
359 assert_equal('one,two', MyDefVarargs('one', 'two'))
360 assert_equal('one,two,three', MyDefVarargs('one', 'two', 'three'))
361enddef
362
Bram Moolenaar42a480b2020-02-29 23:23:47 +0100363def Test_using_var_as_arg()
364 call writefile(['def Func(x: number)', 'let x = 234', 'enddef'], 'Xdef')
365 call assert_fails('so Xdef', 'E1006:')
366 call delete('Xdef')
367enddef
368
Bram Moolenaarb35efa52020-02-26 20:15:18 +0100369def Test_call_func_defined_later()
370 call assert_equal('one', DefinedLater('one'))
371 call assert_fails('call NotDefined("one")', 'E117:')
372enddef
Bram Moolenaar170fcfc2020-02-06 17:51:35 +0100373
Bram Moolenaarb35efa52020-02-26 20:15:18 +0100374func DefinedLater(arg)
Bram Moolenaar26e117e2020-02-04 21:24:15 +0100375 return a:arg
376endfunc
377
Bram Moolenaar7eeefd42020-02-26 21:24:23 +0100378def FuncWithForwardCall()
379 return DefinedEvenLater("yes")
380enddef
381
382def DefinedEvenLater(arg: string): string
383 return arg
384enddef
385
386def Test_error_in_nested_function()
387 " Error in called function requires unwinding the call stack.
388 assert_fails('call FuncWithForwardCall()', 'E1029')
389enddef
390
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100391def Test_return_type_wrong()
Bram Moolenaar978d1702020-01-26 17:38:12 +0100392 CheckScriptFailure(['def Func(): number', 'return "a"', 'enddef'], 'expected number but got string')
393 CheckScriptFailure(['def Func(): string', 'return 1', 'enddef'], 'expected string but got number')
394 CheckScriptFailure(['def Func(): void', 'return "a"', 'enddef'], 'expected void but got string')
395 CheckScriptFailure(['def Func()', 'return "a"', 'enddef'], 'expected void but got string')
Bram Moolenaarcf3f8bf2020-03-26 13:15:42 +0100396
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200397 CheckScriptFailure(['def Func(): number', 'return', 'enddef'], 'E1003:')
398
Bram Moolenaarcf3f8bf2020-03-26 13:15:42 +0100399 CheckScriptFailure(['def Func(): list', 'return []', 'enddef'], 'E1008:')
400 CheckScriptFailure(['def Func(): dict', 'return {}', 'enddef'], 'E1008:')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100401enddef
402
Bram Moolenaarbfe12042020-02-04 21:54:07 +0100403def Test_arg_type_wrong()
404 CheckScriptFailure(['def Func3(items: list)', 'echo "a"', 'enddef'], 'E1008: Missing <type>')
405enddef
406
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100407def Test_try_catch()
408 let l = []
409 try
410 add(l, '1')
411 throw 'wrong'
412 add(l, '2')
413 catch
414 add(l, v:exception)
415 finally
416 add(l, '3')
417 endtry
418 assert_equal(['1', 'wrong', '3'], l)
419enddef
420
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100421def ThrowFromDef()
422 throw 'getout'
423enddef
424
425func CatchInFunc()
426 try
427 call ThrowFromDef()
428 catch
429 let g:thrown_func = v:exception
430 endtry
431endfunc
432
433def CatchInDef()
434 try
435 ThrowFromDef()
436 catch
437 g:thrown_def = v:exception
438 endtry
439enddef
440
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100441def ReturnFinally(): string
442 try
443 return 'intry'
444 finally
445 g:in_finally = 'finally'
446 endtry
447 return 'end'
448enddef
449
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100450def Test_try_catch_nested()
451 CatchInFunc()
452 assert_equal('getout', g:thrown_func)
453
454 CatchInDef()
455 assert_equal('getout', g:thrown_def)
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100456
457 assert_equal('intry', ReturnFinally())
458 assert_equal('finally', g:in_finally)
459enddef
460
461def Test_try_catch_match()
462 let seq = 'a'
463 try
464 throw 'something'
465 catch /nothing/
466 seq ..= 'x'
467 catch /some/
468 seq ..= 'b'
469 catch /asdf/
470 seq ..= 'x'
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200471 catch ?a\?sdf?
472 seq ..= 'y'
Bram Moolenaarf575adf2020-02-20 20:41:06 +0100473 finally
474 seq ..= 'c'
475 endtry
476 assert_equal('abc', seq)
Bram Moolenaar257cc5e2020-02-19 17:06:11 +0100477enddef
478
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200479def Test_try_catch_fails()
480 call CheckDefFailure(['catch'], 'E603:')
481 call CheckDefFailure(['try', 'echo 0', 'catch','catch'], 'E1033:')
482 call CheckDefFailure(['try', 'echo 0', 'catch /pat'], 'E1067:')
483enddef
484
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100485let s:export_script_lines =<< trim END
486 vim9script
487 let name: string = 'bob'
488 def Concat(arg: string): string
489 return name .. arg
490 enddef
491 let g:result = Concat('bie')
492 let g:localname = name
493
494 export const CONST = 1234
495 export let exported = 9876
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100496 export let exp_name = 'John'
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100497 export def Exported(): string
498 return 'Exported'
499 enddef
500END
501
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100502def Test_vim9_import_export()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100503 let import_script_lines =<< trim END
504 vim9script
505 import {exported, Exported} from './Xexport.vim'
506 g:imported = exported
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100507 exported += 3
508 g:imported_added = exported
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100509 g:imported_func = Exported()
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100510
511 import {exp_name} from './Xexport.vim'
512 g:imported_name = exp_name
513 exp_name ..= ' Doe'
514 g:imported_name_appended = exp_name
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100515 g:imported_later = exported
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100516 END
517
518 writefile(import_script_lines, 'Ximport.vim')
519 writefile(s:export_script_lines, 'Xexport.vim')
520
521 source Ximport.vim
522
523 assert_equal('bobbie', g:result)
524 assert_equal('bob', g:localname)
525 assert_equal(9876, g:imported)
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100526 assert_equal(9879, g:imported_added)
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100527 assert_equal(9879, g:imported_later)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100528 assert_equal('Exported', g:imported_func)
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100529 assert_equal('John', g:imported_name)
530 assert_equal('John Doe', g:imported_name_appended)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100531 assert_false(exists('g:name'))
532
533 unlet g:result
534 unlet g:localname
535 unlet g:imported
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100536 unlet g:imported_added
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100537 unlet g:imported_later
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100538 unlet g:imported_func
Bram Moolenaar6e587dc2020-02-06 13:15:52 +0100539 unlet g:imported_name g:imported_name_appended
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100540 delete('Ximport.vim')
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100541
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100542 let import_in_def_lines =<< trim END
543 vim9script
544 def ImportInDef()
545 import exported from './Xexport.vim'
546 g:imported = exported
547 exported += 7
548 g:imported_added = exported
549 enddef
550 ImportInDef()
551 END
552 writefile(import_in_def_lines, 'Ximport2.vim')
553 source Ximport2.vim
554 " TODO: this should be 9879
555 assert_equal(9876, g:imported)
556 assert_equal(9883, g:imported_added)
557 unlet g:imported
558 unlet g:imported_added
559 delete('Ximport2.vim')
560
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100561 let import_star_as_lines =<< trim END
562 vim9script
563 import * as Export from './Xexport.vim'
564 def UseExport()
565 g:imported = Export.exported
566 enddef
567 UseExport()
568 END
569 writefile(import_star_as_lines, 'Ximport.vim')
570 source Ximport.vim
Bram Moolenaar5381c7a2020-03-02 22:53:32 +0100571 assert_equal(9883, g:imported)
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100572
Bram Moolenaar599c89c2020-03-28 14:53:20 +0100573 let import_star_as_lines_no_dot =<< trim END
574 vim9script
575 import * as Export from './Xexport.vim'
576 def Func()
577 let dummy = 1
578 let imported = Export + dummy
579 enddef
580 END
581 writefile(import_star_as_lines_no_dot, 'Ximport.vim')
582 assert_fails('source Ximport.vim', 'E1060:')
583
584 let import_star_as_lines_dot_space =<< trim END
585 vim9script
586 import * as Export from './Xexport.vim'
587 def Func()
588 let imported = Export . exported
589 enddef
590 END
591 writefile(import_star_as_lines_dot_space, 'Ximport.vim')
592 assert_fails('source Ximport.vim', 'E1074:')
593
594 let import_star_as_lines_missing_name =<< trim END
595 vim9script
596 import * as Export from './Xexport.vim'
597 def Func()
598 let imported = Export.
599 enddef
600 END
601 writefile(import_star_as_lines_missing_name, 'Ximport.vim')
602 assert_fails('source Ximport.vim', 'E1048:')
603
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100604 let import_star_lines =<< trim END
605 vim9script
606 import * from './Xexport.vim'
607 g:imported = exported
608 END
609 writefile(import_star_lines, 'Ximport.vim')
610 assert_fails('source Ximport.vim', 'E1045:')
611
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +0100612 " try to import something that exists but is not exported
613 let import_not_exported_lines =<< trim END
614 vim9script
615 import name from './Xexport.vim'
616 END
617 writefile(import_not_exported_lines, 'Ximport.vim')
618 assert_fails('source Ximport.vim', 'E1049:')
619
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100620 " try to import something that is already defined
621 let import_already_defined =<< trim END
622 vim9script
623 let exported = 'something'
624 import exported from './Xexport.vim'
625 END
626 writefile(import_already_defined, 'Ximport.vim')
627 assert_fails('source Ximport.vim', 'E1073:')
628
629 " try to import something that is already defined
630 import_already_defined =<< trim END
631 vim9script
632 let exported = 'something'
633 import * as exported from './Xexport.vim'
634 END
635 writefile(import_already_defined, 'Ximport.vim')
636 assert_fails('source Ximport.vim', 'E1073:')
637
638 " try to import something that is already defined
639 import_already_defined =<< trim END
640 vim9script
641 let exported = 'something'
642 import {exported} from './Xexport.vim'
643 END
644 writefile(import_already_defined, 'Ximport.vim')
645 assert_fails('source Ximport.vim', 'E1073:')
646
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +0100647 " import a very long name, requires making a copy
648 let import_long_name_lines =<< trim END
649 vim9script
650 import name012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 from './Xexport.vim'
651 END
652 writefile(import_long_name_lines, 'Ximport.vim')
653 assert_fails('source Ximport.vim', 'E1048:')
654
655 let import_no_from_lines =<< trim END
656 vim9script
657 import name './Xexport.vim'
658 END
659 writefile(import_no_from_lines, 'Ximport.vim')
660 assert_fails('source Ximport.vim', 'E1070:')
661
662 let import_invalid_string_lines =<< trim END
663 vim9script
664 import name from Xexport.vim
665 END
666 writefile(import_invalid_string_lines, 'Ximport.vim')
667 assert_fails('source Ximport.vim', 'E1071:')
668
669 let import_wrong_name_lines =<< trim END
670 vim9script
671 import name from './XnoExport.vim'
672 END
673 writefile(import_wrong_name_lines, 'Ximport.vim')
674 assert_fails('source Ximport.vim', 'E1053:')
675
676 let import_missing_comma_lines =<< trim END
677 vim9script
678 import {exported name} from './Xexport.vim'
679 END
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100680 writefile(import_missing_comma_lines, 'Ximport3.vim')
681 assert_fails('source Ximport3.vim', 'E1046:')
Bram Moolenaarfa29c8a2020-02-23 22:35:05 +0100682
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100683 delete('Ximport.vim')
Bram Moolenaar5269bd22020-03-09 19:25:27 +0100684 delete('Ximport3.vim')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100685 delete('Xexport.vim')
686
Bram Moolenaar750802b2020-02-23 18:08:33 +0100687 " Check that in a Vim9 script 'cpo' is set to the Vim default.
688 set cpo&vi
689 let cpo_before = &cpo
690 let lines =<< trim END
691 vim9script
692 g:cpo_in_vim9script = &cpo
693 END
694 writefile(lines, 'Xvim9_script')
695 source Xvim9_script
696 assert_equal(cpo_before, &cpo)
697 set cpo&vim
698 assert_equal(&cpo, g:cpo_in_vim9script)
699 delete('Xvim9_script')
700enddef
701
702def Test_vim9script_fails()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100703 CheckScriptFailure(['scriptversion 2', 'vim9script'], 'E1039:')
704 CheckScriptFailure(['vim9script', 'scriptversion 2'], 'E1040:')
Bram Moolenaar750802b2020-02-23 18:08:33 +0100705 CheckScriptFailure(['export let some = 123'], 'E1042:')
Bram Moolenaarf2d5c242020-02-23 21:25:54 +0100706 CheckScriptFailure(['import some from "./Xexport.vim"'], 'E1042:')
Bram Moolenaar750802b2020-02-23 18:08:33 +0100707 CheckScriptFailure(['vim9script', 'export let g:some'], 'E1044:')
708 CheckScriptFailure(['vim9script', 'export echo 134'], 'E1043:')
709
710 assert_fails('vim9script', 'E1038')
711 assert_fails('export something', 'E1042')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100712enddef
713
714def Test_vim9script_call()
715 let lines =<< trim END
716 vim9script
717 let var = ''
718 def MyFunc(arg: string)
719 var = arg
720 enddef
721 MyFunc('foobar')
722 assert_equal('foobar', var)
723
724 let str = 'barfoo'
725 str->MyFunc()
726 assert_equal('barfoo', var)
727
728 let g:value = 'value'
729 g:value->MyFunc()
730 assert_equal('value', var)
731
732 let listvar = []
733 def ListFunc(arg: list<number>)
734 listvar = arg
735 enddef
736 [1, 2, 3]->ListFunc()
737 assert_equal([1, 2, 3], listvar)
738
739 let dictvar = {}
740 def DictFunc(arg: dict<number>)
741 dictvar = arg
742 enddef
743 {'a': 1, 'b': 2}->DictFunc()
744 assert_equal(#{a: 1, b: 2}, dictvar)
Bram Moolenaar33fa29c2020-03-28 19:41:33 +0100745 def CompiledDict()
746 {'a': 3, 'b': 4}->DictFunc()
747 enddef
748 CompiledDict()
749 assert_equal(#{a: 3, b: 4}, dictvar)
750
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100751 #{a: 3, b: 4}->DictFunc()
752 assert_equal(#{a: 3, b: 4}, dictvar)
Bram Moolenaar0c6ceaf2020-02-22 18:36:32 +0100753
754 ('text')->MyFunc()
755 assert_equal('text', var)
756 ("some")->MyFunc()
757 assert_equal('some', var)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100758 END
759 writefile(lines, 'Xcall.vim')
760 source Xcall.vim
761 delete('Xcall.vim')
762enddef
763
764def Test_vim9script_call_fail_decl()
765 let lines =<< trim END
766 vim9script
767 let var = ''
768 def MyFunc(arg: string)
769 let var = 123
770 enddef
771 END
772 writefile(lines, 'Xcall_decl.vim')
773 assert_fails('source Xcall_decl.vim', 'E1054:')
774 delete('Xcall_decl.vim')
775enddef
776
777def Test_vim9script_call_fail_const()
778 let lines =<< trim END
779 vim9script
780 const var = ''
781 def MyFunc(arg: string)
782 var = 'asdf'
783 enddef
784 END
785 writefile(lines, 'Xcall_const.vim')
786 assert_fails('source Xcall_const.vim', 'E46:')
787 delete('Xcall_const.vim')
788enddef
789
790def Test_vim9script_reload()
791 let lines =<< trim END
792 vim9script
793 const var = ''
794 let valone = 1234
795 def MyFunc(arg: string)
796 valone = 5678
797 enddef
798 END
799 let morelines =<< trim END
800 let valtwo = 222
801 export def GetValtwo(): number
802 return valtwo
803 enddef
804 END
805 writefile(lines + morelines, 'Xreload.vim')
806 source Xreload.vim
807 source Xreload.vim
808 source Xreload.vim
809
810 let testlines =<< trim END
811 vim9script
812 def TheFunc()
813 import GetValtwo from './Xreload.vim'
814 assert_equal(222, GetValtwo())
815 enddef
816 TheFunc()
817 END
818 writefile(testlines, 'Ximport.vim')
819 source Ximport.vim
820
821 " test that when not using "morelines" valtwo is still defined
822 " need to source Xreload.vim again, import doesn't reload a script
823 writefile(lines, 'Xreload.vim')
824 source Xreload.vim
825 source Ximport.vim
826
827 " cannot declare a var twice
828 lines =<< trim END
829 vim9script
830 let valone = 1234
831 let valone = 5678
832 END
833 writefile(lines, 'Xreload.vim')
834 assert_fails('source Xreload.vim', 'E1041:')
835
836 delete('Xreload.vim')
837 delete('Ximport.vim')
838enddef
839
840def Test_import_absolute()
841 let import_lines = [
842 \ 'vim9script',
843 \ 'import exported from "' .. escape(getcwd(), '\') .. '/Xexport_abs.vim"',
Bram Moolenaarb283a8a2020-02-02 22:24:04 +0100844 \ 'def UseExported()',
845 \ ' g:imported_abs = exported',
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +0100846 \ ' exported = 8888',
847 \ ' g:imported_after = exported',
Bram Moolenaarb283a8a2020-02-02 22:24:04 +0100848 \ 'enddef',
849 \ 'UseExported()',
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +0100850 \ 'g:import_disassembled = execute("disass UseExported")',
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100851 \ ]
852 writefile(import_lines, 'Ximport_abs.vim')
853 writefile(s:export_script_lines, 'Xexport_abs.vim')
854
855 source Ximport_abs.vim
856
857 assert_equal(9876, g:imported_abs)
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +0100858 assert_equal(8888, g:imported_after)
Bram Moolenaarb283a8a2020-02-02 22:24:04 +0100859 assert_match('<SNR>\d\+_UseExported.*'
860 \ .. 'g:imported_abs = exported.*'
861 \ .. '0 LOADSCRIPT exported from .*Xexport_abs.vim.*'
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +0100862 \ .. '1 STOREG g:imported_abs.*'
863 \ .. 'exported = 8888.*'
864 \ .. '3 STORESCRIPT exported in .*Xexport_abs.vim.*'
865 \ .. 'g:imported_after = exported.*'
866 \ .. '4 LOADSCRIPT exported from .*Xexport_abs.vim.*'
867 \ .. '5 STOREG g:imported_after.*'
868 \, g:import_disassembled)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100869 unlet g:imported_abs
Bram Moolenaar4e12a5d2020-02-03 20:50:59 +0100870 unlet g:import_disassembled
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100871
872 delete('Ximport_abs.vim')
873 delete('Xexport_abs.vim')
874enddef
875
876def Test_import_rtp()
877 let import_lines = [
878 \ 'vim9script',
879 \ 'import exported from "Xexport_rtp.vim"',
880 \ 'g:imported_rtp = exported',
881 \ ]
882 writefile(import_lines, 'Ximport_rtp.vim')
883 mkdir('import')
884 writefile(s:export_script_lines, 'import/Xexport_rtp.vim')
885
886 let save_rtp = &rtp
887 &rtp = getcwd()
888 source Ximport_rtp.vim
889 &rtp = save_rtp
890
891 assert_equal(9876, g:imported_rtp)
892 unlet g:imported_rtp
893
894 delete('Ximport_rtp.vim')
895 delete('import/Xexport_rtp.vim')
896 delete('import', 'd')
897enddef
898
899def Test_fixed_size_list()
900 " will be allocated as one piece of memory, check that changes work
901 let l = [1, 2, 3, 4]
902 l->remove(0)
903 l->add(5)
904 l->insert(99, 1)
Bram Moolenaar0f18b6d2020-02-02 17:22:27 +0100905 assert_equal([2, 99, 3, 4, 5], l)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100906enddef
907
Bram Moolenaar673660a2020-01-26 16:50:05 +0100908" Test that inside :function a Python function can be defined, :def is not
909" recognized.
910func Test_function_python()
911 CheckFeature python3
912 let py = 'python3'
913 execute py "<< EOF"
914def do_something():
915 return 1
916EOF
917endfunc
918
Bram Moolenaar158906c2020-02-06 20:39:45 +0100919def IfElse(what: number): string
920 let res = ''
921 if what == 1
922 res = "one"
923 elseif what == 2
924 res = "two"
Bram Moolenaara259d8d2020-01-31 20:10:50 +0100925 else
Bram Moolenaar158906c2020-02-06 20:39:45 +0100926 res = "three"
Bram Moolenaara259d8d2020-01-31 20:10:50 +0100927 endif
Bram Moolenaar158906c2020-02-06 20:39:45 +0100928 return res
Bram Moolenaara259d8d2020-01-31 20:10:50 +0100929enddef
930
Bram Moolenaar158906c2020-02-06 20:39:45 +0100931def Test_if_elseif_else()
932 assert_equal('one', IfElse(1))
933 assert_equal('two', IfElse(2))
934 assert_equal('three', IfElse(3))
Bram Moolenaar0f18b6d2020-02-02 17:22:27 +0100935enddef
936
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200937def Test_if_elseif_else_fails()
938 call CheckDefFailure(['elseif true'], 'E582:')
939 call CheckDefFailure(['else'], 'E581:')
940 call CheckDefFailure(['endif'], 'E580:')
941 call CheckDefFailure(['if true', 'elseif xxx'], 'E1001:')
942enddef
943
Bram Moolenaar6d69bf62020-03-03 19:02:12 +0100944let g:bool_true = v:true
945let g:bool_false = v:false
946
947def Test_if_const_expr()
948 let res = false
949 if true ? true : false
950 res = true
951 endif
952 assert_equal(true, res)
953
954 res = false
955 if g:bool_true ? true : false
956 res = true
957 endif
958 assert_equal(true, res)
959
960 res = false
961 if true ? g:bool_true : false
962 res = true
963 endif
964 assert_equal(true, res)
965
966 res = false
967 if true ? true : g:bool_false
968 res = true
969 endif
970 assert_equal(true, res)
971
972 res = false
973 if true ? false : true
974 res = true
975 endif
976 assert_equal(false, res)
977
978 res = false
979 if false ? false : true
980 res = true
981 endif
982 assert_equal(true, res)
983
984 res = false
985 if false ? true : false
986 res = true
987 endif
988 assert_equal(false, res)
989
990 res = false
Bram Moolenaare8c4abb2020-04-02 21:13:25 +0200991 if has('xyz') ? true : false
992 res = true
993 endif
994 assert_equal(false, res)
995
996 res = false
Bram Moolenaar6d69bf62020-03-03 19:02:12 +0100997 if true && true
998 res = true
999 endif
1000 assert_equal(true, res)
1001
1002 res = false
1003 if true && false
1004 res = true
1005 endif
1006 assert_equal(false, res)
1007
1008 res = false
1009 if g:bool_true && false
1010 res = true
1011 endif
1012 assert_equal(false, res)
1013
1014 res = false
1015 if true && g:bool_false
1016 res = true
1017 endif
1018 assert_equal(false, res)
1019
1020 res = false
1021 if false && false
1022 res = true
1023 endif
1024 assert_equal(false, res)
1025
1026 res = false
1027 if true || false
1028 res = true
1029 endif
1030 assert_equal(true, res)
1031
1032 res = false
1033 if g:bool_true || false
1034 res = true
1035 endif
1036 assert_equal(true, res)
1037
1038 res = false
1039 if true || g:bool_false
1040 res = true
1041 endif
1042 assert_equal(true, res)
1043
1044 res = false
1045 if false || false
1046 res = true
1047 endif
1048 assert_equal(false, res)
Bram Moolenaar80c34ca2020-04-01 23:05:18 +02001049enddef
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001050
Bram Moolenaar80c34ca2020-04-01 23:05:18 +02001051def Test_if_const_expr_fails()
1052 call CheckDefFailure(['if "aaa" == "bbb'], 'E114:')
1053 call CheckDefFailure(["if 'aaa' == 'bbb"], 'E115:')
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001054 call CheckDefFailure(["if has('aaa'"], 'E110:')
1055 call CheckDefFailure(["if has('aaa') ? true false"], 'E109:')
Bram Moolenaar6d69bf62020-03-03 19:02:12 +01001056enddef
1057
Bram Moolenaar63ce4842020-02-19 15:46:48 +01001058def Test_delfunc()
1059 let lines =<< trim END
1060 vim9script
1061 def GoneSoon()
1062 echo 'hello'
1063 enddef
1064
1065 def CallGoneSoon()
1066 GoneSoon()
1067 enddef
1068
1069 delfunc GoneSoon
1070 CallGoneSoon()
1071 END
1072 writefile(lines, 'XToDelFunc')
1073 assert_fails('so XToDelFunc', 'E933')
1074 assert_fails('so XToDelFunc', 'E933')
1075
1076 delete('XToDelFunc')
1077enddef
1078
Bram Moolenaarad39c092020-02-26 18:23:43 +01001079def Test_execute_cmd()
1080 new
1081 setline(1, 'default')
1082 execute 'call setline(1, "execute-string")'
1083 assert_equal('execute-string', getline(1))
1084 let cmd1 = 'call setline(1,'
1085 let cmd2 = '"execute-var")'
1086 execute cmd1 cmd2
1087 assert_equal('execute-var', getline(1))
1088 execute cmd1 cmd2 '|call setline(1, "execute-var-string")'
1089 assert_equal('execute-var-string', getline(1))
1090 let cmd_first = 'call '
1091 let cmd_last = 'setline(1, "execute-var-var")'
1092 execute cmd_first .. cmd_last
1093 assert_equal('execute-var-var', getline(1))
1094 bwipe!
1095enddef
1096
1097def Test_echo_cmd()
1098 echo 'something'
1099 assert_match('^something$', Screenline(&lines))
1100
1101 let str1 = 'some'
1102 let str2 = 'more'
1103 echo str1 str2
1104 assert_match('^some more$', Screenline(&lines))
1105enddef
1106
Bram Moolenaar41fe0612020-03-01 16:22:40 +01001107def Test_for_outside_of_function()
1108 let lines =<< trim END
1109 vim9script
1110 new
1111 for var in range(0, 3)
1112 append(line('$'), var)
1113 endfor
1114 assert_equal(['', '0', '1', '2', '3'], getline(1, '$'))
1115 bwipe!
1116 END
1117 writefile(lines, 'Xvim9for.vim')
1118 source Xvim9for.vim
1119 delete('Xvim9for.vim')
1120enddef
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001121
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001122def Test_for_loop()
1123 let result = ''
1124 for cnt in range(7)
1125 if cnt == 4
1126 break
1127 endif
1128 if cnt == 2
1129 continue
1130 endif
1131 result ..= cnt .. '_'
1132 endfor
1133 assert_equal('0_1_3_', result)
1134enddef
1135
1136def Test_for_loop_fails()
1137 call CheckDefFailure(['for # in range(5)'], 'E690:')
1138 call CheckDefFailure(['for i In range(5)'], 'E690:')
1139 call CheckDefFailure(['let x = 5', 'for x in range(5)'], 'E1023:')
1140 call CheckScriptFailure(['def Func(arg)', 'for arg in range(5)', 'enddef'], 'E1006:')
1141 call CheckDefFailure(['for i in "text"'], 'E1024:')
1142 call CheckDefFailure(['for i in xxx'], 'E1001:')
1143 call CheckDefFailure(['endfor'], 'E588:')
1144enddef
1145
Bram Moolenaard0df1aa2020-03-04 21:50:46 +01001146def Test_while_loop()
1147 let result = ''
1148 let cnt = 0
1149 while cnt < 555
1150 if cnt == 3
1151 break
1152 endif
1153 cnt += 1
1154 if cnt == 2
1155 continue
1156 endif
1157 result ..= cnt .. '_'
1158 endwhile
1159 assert_equal('1_3_', result)
1160enddef
1161
Bram Moolenaare8c4abb2020-04-02 21:13:25 +02001162def Test_while_loop_fails()
1163 call CheckDefFailure(['while xxx'], 'E1001:')
1164 call CheckDefFailure(['endwhile'], 'E588:')
1165 call CheckDefFailure(['continue'], 'E586:')
1166 call CheckDefFailure(['if true', 'continue'], 'E586:')
1167 call CheckDefFailure(['break'], 'E587:')
1168 call CheckDefFailure(['if true', 'break'], 'E587:')
Bram Moolenaarbd5da372020-03-31 23:13:10 +02001169enddef
1170
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01001171def Test_interrupt_loop()
Bram Moolenaar97acfc72020-03-22 13:44:28 +01001172 let caught = false
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01001173 let x = 0
Bram Moolenaar97acfc72020-03-22 13:44:28 +01001174 try
1175 while 1
1176 x += 1
1177 if x == 100
1178 feedkeys("\<C-C>", 'Lt')
1179 endif
1180 endwhile
1181 catch
1182 caught = true
1183 assert_equal(100, x)
1184 endtry
1185 assert_true(caught, 'should have caught an exception')
Bram Moolenaar9645e2d2020-03-20 20:48:49 +01001186enddef
Bram Moolenaar20431c92020-03-20 18:39:46 +01001187
Bram Moolenaard0df1aa2020-03-04 21:50:46 +01001188def Test_substitute_cmd()
1189 new
1190 setline(1, 'something')
1191 :substitute(some(other(
1192 assert_equal('otherthing', getline(1))
1193 bwipe!
1194
1195 " also when the context is Vim9 script
1196 let lines =<< trim END
1197 vim9script
1198 new
1199 setline(1, 'something')
1200 :substitute(some(other(
1201 assert_equal('otherthing', getline(1))
1202 bwipe!
1203 END
1204 writefile(lines, 'Xvim9lines')
1205 source Xvim9lines
1206
1207 delete('Xvim9lines')
1208enddef
1209
Bram Moolenaar20431c92020-03-20 18:39:46 +01001210def Test_redef_failure()
1211 call writefile(['def Func0(): string', 'return "Func0"', 'enddef'], 'Xdef')
1212 so Xdef
1213 call writefile(['def Func1(): string', 'return "Func1"', 'enddef'], 'Xdef')
1214 so Xdef
1215 call writefile(['def! Func0(): string', 'enddef'], 'Xdef')
1216 call assert_fails('so Xdef', 'E1027:')
1217 call writefile(['def Func2(): string', 'return "Func2"', 'enddef'], 'Xdef')
1218 so Xdef
1219 call delete('Xdef')
1220
1221 call assert_equal(0, Func0())
1222 call assert_equal('Func1', Func1())
1223 call assert_equal('Func2', Func2())
1224
1225 delfunc! Func0
1226 delfunc! Func1
1227 delfunc! Func2
1228enddef
1229
Bram Moolenaar7d941ee2020-03-26 14:11:58 +01001230" Test for internal functions returning different types
1231func Test_InternalFuncRetType()
1232 let lines =<< trim END
1233 def RetFloat(): float
1234 return ceil(1.456)
1235 enddef
1236
1237 def RetListAny(): list<any>
1238 return items({'k' : 'v'})
1239 enddef
1240
1241 def RetListString(): list<string>
1242 return split('a:b:c', ':')
1243 enddef
1244
1245 def RetListDictAny(): list<dict<any>>
1246 return getbufinfo()
1247 enddef
1248
1249 def RetDictNumber(): dict<number>
1250 return wordcount()
1251 enddef
1252
1253 def RetDictString(): dict<string>
1254 return environ()
1255 enddef
1256 END
1257 call writefile(lines, 'Xscript')
1258 source Xscript
1259
1260 call assert_equal(2.0, RetFloat())
1261 call assert_equal([['k', 'v']], RetListAny())
1262 call assert_equal(['a', 'b', 'c'], RetListString())
1263 call assert_notequal([], RetListDictAny())
1264 call assert_notequal({}, RetDictNumber())
1265 call assert_notequal({}, RetDictString())
1266 call delete('Xscript')
1267endfunc
1268
1269" Test for passing too many or too few arguments to internal functions
1270func Test_internalfunc_arg_error()
1271 let l =<< trim END
1272 def! FArgErr(): float
1273 return ceil(1.1, 2)
1274 enddef
1275 END
1276 call writefile(l, 'Xinvalidarg')
1277 call assert_fails('so Xinvalidarg', 'E118:')
1278 let l =<< trim END
1279 def! FArgErr(): float
1280 return ceil()
1281 enddef
1282 END
1283 call writefile(l, 'Xinvalidarg')
1284 call assert_fails('so Xinvalidarg', 'E119:')
1285 call delete('Xinvalidarg')
1286endfunc
1287
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001288" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker