Mercurial > vim
comparison src/testdir/test_vim9_assign.vim @ 22351:4c488004edbc v8.2.1724
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(['¬ex += 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 |