Mercurial > vim

comparison src/testdir/test_vim9_assign.vim @ 22351:4c488004edbc v8.2.1724

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
patch 8.2.1724: Vim9: assignment tests spread out Commit: https://github.com/vim/vim/commit/971caf53b81b7d1b6fb0bdf32990632975d54631 Author: Bram Moolenaar <Bram@vim.org> Date: Mon Sep 21 22:21:42 2020 +0200 patch 8.2.1724: Vim9: assignment tests spread out Problem: Vim9: assignment tests spread out. Solution: Create new test file for assignment tests.
author Bram Moolenaar <Bram@vim.org>
date Mon, 21 Sep 2020 22:30:03 +0200
parents
children 6c3d15011081
comparison
equal deleted inserted replaced
22350:416fa143fa2d 22351:4c488004edbc
1 " Test Vim9 assignments
2
3 source check.vim
4 source vim9.vim
5
6 let s:appendToMe = 'xxx'
7 let s:addToMe = 111
8 let g:existing = 'yes'
9 let g:inc_counter = 1
10 let $SOME_ENV_VAR = 'some'
11 let g:alist = [7]
12 let g:astring = 'text'
13
14 def Test_assignment_bool()
15 let bool1: bool = true
16 assert_equal(v:true, bool1)
17 let bool2: bool = false
18 assert_equal(v:false, bool2)
19
20 let bool3: bool = 0
21 assert_equal(false, bool3)
22 let bool4: bool = 1
23 assert_equal(true, bool4)
24
25 let bool5: bool = 'yes' && 'no'
26 assert_equal(true, bool5)
27 let bool6: bool = [] && 99
28 assert_equal(false, bool6)
29 let bool7: bool = [] || #{a: 1} && 99
30 assert_equal(true, bool7)
31
32 let lines =<< trim END
33 vim9script
34 def GetFlag(): bool
35 let flag: bool = 1
36 return flag
37 enddef
38 let flag: bool = GetFlag()
39 assert_equal(true, flag)
40 flag = 0
41 assert_equal(false, flag)
42 flag = 1
43 assert_equal(true, flag)
44 flag = 99 || 123
45 assert_equal(true, flag)
46 flag = 'yes' && []
47 assert_equal(false, flag)
48 END
49 CheckScriptSuccess(lines)
50 CheckDefAndScriptFailure(['let x: bool = 2'], 'E1012:')
51 CheckDefAndScriptFailure(['let x: bool = -1'], 'E1012:')
52 CheckDefAndScriptFailure(['let x: bool = [1]'], 'E1012:')
53 CheckDefAndScriptFailure(['let x: bool = {}'], 'E1012:')
54 CheckDefAndScriptFailure(['let x: bool = "x"'], 'E1012:')
55 enddef
56
57 def Test_syntax()
58 let var = 234
59 let other: list<string> = ['asdf']
60 enddef
61
62 def Test_assignment()
63 CheckDefFailure(['let x:string'], 'E1069:')
64 CheckDefFailure(['let x:string = "x"'], 'E1069:')
65 CheckDefFailure(['let a:string = "x"'], 'E1069:')
66 CheckDefFailure(['let lambda = {-> "lambda"}'], 'E704:')
67
68 let nr: number = 1234
69 CheckDefFailure(['let nr: number = "asdf"'], 'E1012:')
70
71 let a: number = 6 #comment
72 assert_equal(6, a)
73
74 if has('channel')
75 let chan1: channel
76 let job1: job
77 let job2: job = job_start('willfail')
78 endif
79 if has('float')
80 let float1: float = 3.4
81 endif
82 let Funky1: func
83 let Funky2: func = function('len')
84 let Party2: func = funcref('g:Test_syntax')
85
86 g:newvar = 'new' #comment
87 assert_equal('new', g:newvar)
88
89 assert_equal('yes', g:existing)
90 g:existing = 'no'
91 assert_equal('no', g:existing)
92
93 v:char = 'abc'
94 assert_equal('abc', v:char)
95
96 $ENVVAR = 'foobar'
97 assert_equal('foobar', $ENVVAR)
98 $ENVVAR = ''
99
100 let lines =<< trim END
101 vim9script
102 $ENVVAR = 'barfoo'
103 assert_equal('barfoo', $ENVVAR)
104 $ENVVAR = ''
105 END
106 CheckScriptSuccess(lines)
107
108 s:appendToMe ..= 'yyy'
109 assert_equal('xxxyyy', s:appendToMe)
110 s:addToMe += 222
111 assert_equal(333, s:addToMe)
112 s:newVar = 'new'
113 assert_equal('new', s:newVar)
114
115 set ts=7
116 &ts += 1
117 assert_equal(8, &ts)
118 &ts -= 3
119 assert_equal(5, &ts)
120 &ts *= 2
121 assert_equal(10, &ts)
122 &ts /= 3
123 assert_equal(3, &ts)
124 set ts=10
125 &ts %= 4
126 assert_equal(2, &ts)
127
128 if has('float')
129 let f100: float = 100.0
130 f100 /= 5
131 assert_equal(20.0, f100)
132
133 let f200: float = 200.0
134 f200 /= 5.0
135 assert_equal(40.0, f200)
136
137 CheckDefFailure(['let nr: number = 200', 'nr /= 5.0'], 'E1012:')
138 endif
139
140 lines =<< trim END
141 &ts = 6
142 &ts += 3
143 assert_equal(9, &ts)
144
145 &l:ts = 6
146 assert_equal(6, &ts)
147 &l:ts += 2
148 assert_equal(8, &ts)
149
150 &g:ts = 6
151 assert_equal(6, &g:ts)
152 &g:ts += 2
153 assert_equal(8, &g:ts)
154 END
155 CheckDefAndScriptSuccess(lines)
156
157 CheckDefFailure(['&notex += 3'], 'E113:')
158 CheckDefFailure(['&ts ..= "xxx"'], 'E1019:')
159 CheckDefFailure(['&ts = [7]'], 'E1012:')
160 CheckDefExecFailure(['&ts = g:alist'], 'E1012: Type mismatch; expected number but got list<number>')
161 CheckDefFailure(['&ts = "xx"'], 'E1012:')
162 CheckDefExecFailure(['&ts = g:astring'], 'E1012: Type mismatch; expected number but got string')
163 CheckDefFailure(['&path += 3'], 'E1012:')
164 CheckDefExecFailure(['&bs = "asdf"'], 'E474:')
165 # test freeing ISN_STOREOPT
166 CheckDefFailure(['&ts = 3', 'let asdf'], 'E1022:')
167 &ts = 8
168
169 lines =<< trim END
170 let save_TI = &t_TI
171 &t_TI = ''
172 assert_equal('', &t_TI)
173 &t_TI = 'xxx'
174 assert_equal('xxx', &t_TI)
175 &t_TI = save_TI
176 END
177 CheckDefAndScriptSuccess(lines)
178
179 CheckDefFailure(['&t_TI = 123'], 'E1012:')
180 CheckScriptFailure(['vim9script', '&t_TI = 123'], 'E928:')
181
182 CheckDefFailure(['let s:var = 123'], 'E1101:')
183 CheckDefFailure(['let s:var: number'], 'E1101:')
184
185 lines =<< trim END
186 vim9script
187 def SomeFunc()
188 s:var = 123
189 enddef
190 defcompile
191 END
192 CheckScriptFailure(lines, 'E1089:')
193
194 g:inc_counter += 1
195 assert_equal(2, g:inc_counter)
196
197 $SOME_ENV_VAR ..= 'more'
198 assert_equal('somemore', $SOME_ENV_VAR)
199 CheckDefFailure(['$SOME_ENV_VAR += "more"'], 'E1051:')
200 CheckDefFailure(['$SOME_ENV_VAR += 123'], 'E1012:')
201
202 lines =<< trim END
203 @c = 'areg'
204 @c ..= 'add'
205 assert_equal('aregadd', @c)
206 END
207 CheckDefAndScriptSuccess(lines)
208
209 CheckDefFailure(['@a += "more"'], 'E1051:')
210 CheckDefFailure(['@a += 123'], 'E1012:')
211
212 v:errmsg = 'none'
213 v:errmsg ..= 'again'
214 assert_equal('noneagain', v:errmsg)
215 CheckDefFailure(['v:errmsg += "more"'], 'E1051:')
216 CheckDefFailure(['v:errmsg += 123'], 'E1012:')
217
218 # this should not leak
219 if 0
220 let text =<< trim END
221 some text
222 END
223 endif
224 enddef
225
226 def Test_single_letter_vars()
227 # single letter variables
228 let a: number = 123
229 a = 123
230 assert_equal(123, a)
231 let b: number
232 b = 123
233 assert_equal(123, b)
234 let g: number
235 g = 123
236 assert_equal(123, g)
237 let s: number
238 s = 123
239 assert_equal(123, s)
240 let t: number
241 t = 123
242 assert_equal(123, t)
243 let v: number
244 v = 123
245 assert_equal(123, v)
246 let w: number
247 w = 123
248 assert_equal(123, w)
249 enddef
250
251 def Test_vim9_single_char_vars()
252 let lines =<< trim END
253 vim9script
254
255 # single character variable declarations work
256 let a: string
257 let b: number
258 let l: list<any>
259 let s: string
260 let t: number
261 let v: number
262 let w: number
263
264 # script-local variables can be used without s: prefix
265 a = 'script-a'
266 b = 111
267 l = [1, 2, 3]
268 s = 'script-s'
269 t = 222
270 v = 333
271 w = 444
272
273 assert_equal('script-a', a)
274 assert_equal(111, b)
275 assert_equal([1, 2, 3], l)
276 assert_equal('script-s', s)
277 assert_equal(222, t)
278 assert_equal(333, v)
279 assert_equal(444, w)
280 END
281 writefile(lines, 'Xsinglechar')
282 source Xsinglechar
283 delete('Xsinglechar')
284 enddef
285
286 def Test_assignment_list()
287 let list1: list<bool> = [false, true, false]
288 let list2: list<number> = [1, 2, 3]
289 let list3: list<string> = ['sdf', 'asdf']
290 let list4: list<any> = ['yes', true, 1234]
291 let list5: list<blob> = [0z01, 0z02]
292
293 let listS: list<string> = []
294 let listN: list<number> = []
295
296 assert_equal([1, 2, 3], list2)
297 list2[-1] = 99
298 assert_equal([1, 2, 99], list2)
299 list2[-2] = 88
300 assert_equal([1, 88, 99], list2)
301 list2[-3] = 77
302 assert_equal([77, 88, 99], list2)
303 list2 += [100]
304 assert_equal([77, 88, 99, 100], list2)
305
306 list3 += ['end']
307 assert_equal(['sdf', 'asdf', 'end'], list3)
308
309 CheckDefExecFailure(['let ll = [1, 2, 3]', 'll[-4] = 6'], 'E684:')
310 CheckDefExecFailure(['let [v1, v2] = [1, 2]'], 'E1092:')
311
312 # type becomes list<any>
313 let somelist = rand() > 0 ? [1, 2, 3] : ['a', 'b', 'c']
314 enddef
315
316 def Test_assignment_list_vim9script()
317 let lines =<< trim END
318 vim9script
319 let v1: number
320 let v2: number
321 let v3: number
322 [v1, v2, v3] = [1, 2, 3]
323 assert_equal([1, 2, 3], [v1, v2, v3])
324 END
325 CheckScriptSuccess(lines)
326 enddef
327
328 def Test_assignment_dict()
329 let dict1: dict<bool> = #{one: false, two: true}
330 let dict2: dict<number> = #{one: 1, two: 2}
331 let dict3: dict<string> = #{key: 'value'}
332 let dict4: dict<any> = #{one: 1, two: '2'}
333 let dict5: dict<blob> = #{one: 0z01, two: 0z02}
334
335 # overwrite
336 dict3['key'] = 'another'
337
338 # empty key can be used
339 let dd = {}
340 dd[""] = 6
341 assert_equal({'': 6}, dd)
342
343 # type becomes dict<any>
344 let somedict = rand() > 0 ? #{a: 1, b: 2} : #{a: 'a', b: 'b'}
345
346 # assignment to script-local dict
347 let lines =<< trim END
348 vim9script
349 let test: dict<any> = {}
350 def FillDict(): dict<any>
351 test['a'] = 43
352 return test
353 enddef
354 assert_equal(#{a: 43}, FillDict())
355 END
356 CheckScriptSuccess(lines)
357
358 lines =<< trim END
359 vim9script
360 let test: dict<any>
361 def FillDict(): dict<any>
362 test['a'] = 43
363 return test
364 enddef
365 FillDict()
366 END
367 CheckScriptFailure(lines, 'E1103:')
368
369 # assignment to global dict
370 lines =<< trim END
371 vim9script
372 g:test = {}
373 def FillDict(): dict<any>
374 g:test['a'] = 43
375 return g:test
376 enddef
377 assert_equal(#{a: 43}, FillDict())
378 END
379 CheckScriptSuccess(lines)
380
381 # assignment to buffer dict
382 lines =<< trim END
383 vim9script
384 b:test = {}
385 def FillDict(): dict<any>
386 b:test['a'] = 43
387 return b:test
388 enddef
389 assert_equal(#{a: 43}, FillDict())
390 END
391 CheckScriptSuccess(lines)
392 enddef
393
394 def Test_assignment_local()
395 # Test in a separated file in order not to the current buffer/window/tab is
396 # changed.
397 let script_lines: list<string> =<< trim END
398 let b:existing = 'yes'
399 let w:existing = 'yes'
400 let t:existing = 'yes'
401
402 def Test_assignment_local_internal()
403 b:newvar = 'new'
404 assert_equal('new', b:newvar)
405 assert_equal('yes', b:existing)
406 b:existing = 'no'
407 assert_equal('no', b:existing)
408 b:existing ..= 'NO'
409 assert_equal('noNO', b:existing)
410
411 w:newvar = 'new'
412 assert_equal('new', w:newvar)
413 assert_equal('yes', w:existing)
414 w:existing = 'no'
415 assert_equal('no', w:existing)
416 w:existing ..= 'NO'
417 assert_equal('noNO', w:existing)
418
419 t:newvar = 'new'
420 assert_equal('new', t:newvar)
421 assert_equal('yes', t:existing)
422 t:existing = 'no'
423 assert_equal('no', t:existing)
424 t:existing ..= 'NO'
425 assert_equal('noNO', t:existing)
426 enddef
427 call Test_assignment_local_internal()
428 END
429 CheckScriptSuccess(script_lines)
430 enddef
431
432 def Test_assignment_default()
433
434 # Test default values.
435 let thebool: bool
436 assert_equal(v:false, thebool)
437
438 let thenumber: number
439 assert_equal(0, thenumber)
440
441 if has('float')
442 let thefloat: float
443 assert_equal(0.0, thefloat)
444 endif
445
446 let thestring: string
447 assert_equal('', thestring)
448
449 let theblob: blob
450 assert_equal(0z, theblob)
451
452 let Thefunc: func
453 assert_equal(test_null_function(), Thefunc)
454
455 let thelist: list<any>
456 assert_equal([], thelist)
457
458 let thedict: dict<any>
459 assert_equal({}, thedict)
460
461 if has('channel')
462 let thejob: job
463 assert_equal(test_null_job(), thejob)
464
465 let thechannel: channel
466 assert_equal(test_null_channel(), thechannel)
467
468 if has('unix') && executable('cat')
469 # check with non-null job and channel, types must match
470 thejob = job_start("cat ", #{})
471 thechannel = job_getchannel(thejob)
472 job_stop(thejob, 'kill')
473 endif
474 endif
475
476 let nr = 1234 | nr = 5678
477 assert_equal(5678, nr)
478 enddef
479
480 def Test_assignment_var_list()
481 let v1: string
482 let v2: string
483 let vrem: list<string>
484 [v1] = ['aaa']
485 assert_equal('aaa', v1)
486
487 [v1, v2] = ['one', 'two']
488 assert_equal('one', v1)
489 assert_equal('two', v2)
490
491 [v1, v2; vrem] = ['one', 'two']
492 assert_equal('one', v1)
493 assert_equal('two', v2)
494 assert_equal([], vrem)
495
496 [v1, v2; vrem] = ['one', 'two', 'three']
497 assert_equal('one', v1)
498 assert_equal('two', v2)
499 assert_equal(['three'], vrem)
500
501 [&ts, &sw] = [3, 4]
502 assert_equal(3, &ts)
503 assert_equal(4, &sw)
504 set ts=8 sw=4
505 enddef
506
507 def Test_assignment_vim9script()
508 let lines =<< trim END
509 vim9script
510 def Func(): list<number>
511 return [1, 2]
512 enddef
513 let var1: number
514 let var2: number
515 [var1, var2] =
516 Func()
517 assert_equal(1, var1)
518 assert_equal(2, var2)
519 let ll =
520 Func()
521 assert_equal([1, 2], ll)
522
523 @/ = 'text'
524 assert_equal('text', @/)
525 @0 = 'zero'
526 assert_equal('zero', @0)
527 @1 = 'one'
528 assert_equal('one', @1)
529 @9 = 'nine'
530 assert_equal('nine', @9)
531 @- = 'minus'
532 assert_equal('minus', @-)
533 if has('clipboard_working')
534 @* = 'star'
535 assert_equal('star', @*)
536 @+ = 'plus'
537 assert_equal('plus', @+)
538 endif
539
540 let a: number = 123
541 assert_equal(123, a)
542 let s: string = 'yes'
543 assert_equal('yes', s)
544 let b: number = 42
545 assert_equal(42, b)
546 let w: number = 43
547 assert_equal(43, w)
548 let t: number = 44
549 assert_equal(44, t)
550 END
551 CheckScriptSuccess(lines)
552 enddef
553
554 def Mess(): string
555 v:foldstart = 123
556 return 'xxx'
557 enddef
558
559 def Test_assignment_failure()
560 CheckDefFailure(['let var=234'], 'E1004:')
561 CheckDefFailure(['let var =234'], 'E1004:')
562 CheckDefFailure(['let var= 234'], 'E1004:')
563
564 CheckScriptFailure(['vim9script', 'let var=234'], 'E1004:')
565 CheckScriptFailure(['vim9script', 'let var=234'], "before and after '='")
566 CheckScriptFailure(['vim9script', 'let var =234'], 'E1004:')
567 CheckScriptFailure(['vim9script', 'let var= 234'], 'E1004:')
568 CheckScriptFailure(['vim9script', 'let var = 234', 'var+=234'], 'E1004:')
569 CheckScriptFailure(['vim9script', 'let var = 234', 'var+=234'], "before and after '+='")
570 CheckScriptFailure(['vim9script', 'let var = "x"', 'var..="y"'], 'E1004:')
571 CheckScriptFailure(['vim9script', 'let var = "x"', 'var..="y"'], "before and after '..='")
572
573 CheckDefFailure(['let true = 1'], 'E1034:')
574 CheckDefFailure(['let false = 1'], 'E1034:')
575
576 CheckDefFailure(['[a; b; c] = g:list'], 'E452:')
577 CheckDefExecFailure(['let a: number',
578 '[a] = test_null_list()'], 'E1093:')
579 CheckDefExecFailure(['let a: number',
580 '[a] = []'], 'E1093:')
581 CheckDefExecFailure(['let x: number',
582 'let y: number',
583 '[x, y] = [1]'], 'E1093:')
584 CheckDefExecFailure(['let x: number',
585 'let y: number',
586 'let z: list<number>',
587 '[x, y; z] = [1]'], 'E1093:')
588
589 CheckDefFailure(['let somevar'], "E1022:")
590 CheckDefFailure(['let &tabstop = 4'], 'E1052:')
591 CheckDefFailure(['&g:option = 5'], 'E113:')
592 CheckScriptFailure(['vim9script', 'let &tabstop = 4'], 'E1052:')
593
594 CheckDefFailure(['let $VAR = 5'], 'E1016: Cannot declare an environment variable:')
595 CheckScriptFailure(['vim9script', 'let $ENV = "xxx"'], 'E1016:')
596
597 if has('dnd')
598 CheckDefFailure(['let @~ = 5'], 'E1066:')
599 else
600 CheckDefFailure(['let @~ = 5'], 'E354:')
601 CheckDefFailure(['@~ = 5'], 'E354:')
602 endif
603 CheckDefFailure(['let @a = 5'], 'E1066:')
604 CheckDefFailure(['let @/ = "x"'], 'E1066:')
605 CheckScriptFailure(['vim9script', 'let @a = "abc"'], 'E1066:')
606
607 CheckDefFailure(['let g:var = 5'], 'E1016: Cannot declare a global variable:')
608 CheckDefFailure(['let w:var = 5'], 'E1016: Cannot declare a window variable:')
609 CheckDefFailure(['let b:var = 5'], 'E1016: Cannot declare a buffer variable:')
610 CheckDefFailure(['let t:var = 5'], 'E1016: Cannot declare a tab variable:')
611
612 CheckDefFailure(['let anr = 4', 'anr ..= "text"'], 'E1019:')
613 CheckDefFailure(['let xnr += 4'], 'E1020:', 1)
614 CheckScriptFailure(['vim9script', 'let xnr += 4'], 'E1020:')
615 CheckDefFailure(["let xnr = xnr + 1"], 'E1001:', 1)
616 CheckScriptFailure(['vim9script', 'let xnr = xnr + 4'], 'E121:')
617
618 CheckScriptFailure(['vim9script', 'def Func()', 'let dummy = s:notfound', 'enddef', 'defcompile'], 'E1108:')
619
620 CheckDefFailure(['let var: list<string> = [123]'], 'expected list<string> but got list<number>')
621 CheckDefFailure(['let var: list<number> = ["xx"]'], 'expected list<number> but got list<string>')
622
623 CheckDefFailure(['let var: dict<string> = #{key: 123}'], 'expected dict<string> but got dict<number>')
624 CheckDefFailure(['let var: dict<number> = #{key: "xx"}'], 'expected dict<number> but got dict<string>')
625
626 CheckDefFailure(['let var = feedkeys("0")'], 'E1031:')
627 CheckDefFailure(['let var: number = feedkeys("0")'], 'expected number but got void')
628
629 CheckDefFailure(['let var: dict <number>'], 'E1068:')
630 CheckDefFailure(['let var: dict<number'], 'E1009:')
631
632 assert_fails('s/^/\=Mess()/n', 'E794:')
633 CheckDefFailure(['let var: dict<number'], 'E1009:')
634
635 CheckDefFailure(['w:foo: number = 10'],
636 'E488: Trailing characters: : number = 1')
637 CheckDefFailure(['t:foo: bool = true'],
638 'E488: Trailing characters: : bool = true')
639 CheckDefFailure(['b:foo: string = "x"'],
640 'E488: Trailing characters: : string = "x"')
641 CheckDefFailure(['g:foo: number = 123'],
642 'E488: Trailing characters: : number = 123')
643 enddef
644
645 def Test_assign_list()
646 let l: list<string> = []
647 l[0] = 'value'
648 assert_equal('value', l[0])
649
650 l[1] = 'asdf'
651 assert_equal('value', l[0])
652 assert_equal('asdf', l[1])
653 assert_equal('asdf', l[-1])
654 assert_equal('value', l[-2])
655
656 let nrl: list<number> = []
657 for i in range(5)
658 nrl[i] = i
659 endfor
660 assert_equal([0, 1, 2, 3, 4], nrl)
661 enddef
662
663 def Test_assign_dict()
664 let d: dict<string> = {}
665 d['key'] = 'value'
666 assert_equal('value', d['key'])
667
668 d[123] = 'qwerty'
669 assert_equal('qwerty', d[123])
670 assert_equal('qwerty', d['123'])
671
672 let nrd: dict<number> = {}
673 for i in range(3)
674 nrd[i] = i
675 endfor
676 assert_equal({'0': 0, '1': 1, '2': 2}, nrd)
677 enddef
678
679 def Test_assign_lambda()
680 # check if assign a lambda to a variable which type is func or any.
681 let lines =<< trim END
682 vim9script
683 let FuncRef = {->123}
684 assert_equal(123, FuncRef())
685 let FuncRef_Func: func = {->123}
686 assert_equal(123, FuncRef_Func())
687 let FuncRef_Any: any = {->123}
688 assert_equal(123, FuncRef_Any())
689 END
690 CheckScriptSuccess(lines)
691 enddef
692
693 " vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker