Mercurial > vim
comparison src/testdir/test_listdict.vim @ 27457:4c16acb2525f v8.2.4257
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Commit: https://github.com/vim/vim/commit/62aec93bfdb9e1b40d03a6d2e8e9511f8b1bdb2d
Author: Bram Moolenaar <Bram@vim.org>
Date: Sat Jan 29 21:45:34 2022 +0000
patch 8.2.4257: Vim9: finding global function without g: prefix inconsistent
Problem: Vim9: finding global function without g: prefix but not finding
global variable is inconsistent.
Solution: Require using g: for a global function. Change the vim9.vim
script into a Vim9 script with exports. Fix that import in legacy
script does not work.
author | Bram Moolenaar <Bram@vim.org> |
---|---|
date | Sat, 29 Jan 2022 23:00:05 +0100 |
parents | 31c23760d590 |
children | efbce802c0df |
comparison
equal
deleted
inserted
replaced
27456:a8e2d91995ce | 27457:4c16acb2525f |
---|---|
1 " Tests for the List and Dict types | 1 " Tests for the List and Dict types |
2 scriptencoding utf-8 | 2 scriptencoding utf-8 |
3 | 3 |
4 source vim9.vim | 4 import './vim9.vim' as v9 |
5 | 5 |
6 func TearDown() | 6 func TearDown() |
7 " Run garbage collection after every test | 7 " Run garbage collection after every test |
8 call test_garbagecollect_now() | 8 call test_garbagecollect_now() |
9 endfunc | 9 endfunc |
48 VAR l = [1, 2] | 48 VAR l = [1, 2] |
49 call assert_equal([1, 2], l[:]) | 49 call assert_equal([1, 2], l[:]) |
50 call assert_equal([2], l[-1 : -1]) | 50 call assert_equal([2], l[-1 : -1]) |
51 call assert_equal([1, 2], l[-2 : -1]) | 51 call assert_equal([1, 2], l[-2 : -1]) |
52 END | 52 END |
53 call CheckLegacyAndVim9Success(lines) | 53 call v9.CheckLegacyAndVim9Success(lines) |
54 | 54 |
55 let l = [1, 2] | 55 let l = [1, 2] |
56 call assert_equal([], l[-3 : -1]) | 56 call assert_equal([], l[-3 : -1]) |
57 | 57 |
58 let lines =<< trim END | 58 let lines =<< trim END |
59 var l = [1, 2] | 59 var l = [1, 2] |
60 assert_equal([1, 2], l[-3 : -1]) | 60 assert_equal([1, 2], l[-3 : -1]) |
61 END | 61 END |
62 call CheckDefAndScriptSuccess(lines) | 62 call v9.CheckDefAndScriptSuccess(lines) |
63 endfunc | 63 endfunc |
64 | 64 |
65 " List identity | 65 " List identity |
66 func Test_list_identity() | 66 func Test_list_identity() |
67 let lines =<< trim END | 67 let lines =<< trim END |
73 call assert_true(l is ll) | 73 call assert_true(l is ll) |
74 call assert_true(l == lx) | 74 call assert_true(l == lx) |
75 call assert_false(l is lx) | 75 call assert_false(l is lx) |
76 call assert_true(l isnot lx) | 76 call assert_true(l isnot lx) |
77 END | 77 END |
78 call CheckLegacyAndVim9Success(lines) | 78 call v9.CheckLegacyAndVim9Success(lines) |
79 endfunc | 79 endfunc |
80 | 80 |
81 " removing items with :unlet | 81 " removing items with :unlet |
82 func Test_list_unlet() | 82 func Test_list_unlet() |
83 let lines =<< trim END | 83 let lines =<< trim END |
116 call assert_equal([3], l) | 116 call assert_equal([3], l) |
117 LET l = [0, 1, 2, 3] | 117 LET l = [0, 1, 2, 3] |
118 unlet l[-6 : 2] | 118 unlet l[-6 : 2] |
119 call assert_equal([3], l) | 119 call assert_equal([3], l) |
120 END | 120 END |
121 call CheckLegacyAndVim9Success(lines) | 121 call v9.CheckLegacyAndVim9Success(lines) |
122 | 122 |
123 let l = [0, 1, 2, 3] | 123 let l = [0, 1, 2, 3] |
124 unlet l[2:2] | 124 unlet l[2:2] |
125 call assert_equal([0, 1, 3], l) | 125 call assert_equal([0, 1, 3], l) |
126 let l = [0, 1, 2, 3] | 126 let l = [0, 1, 2, 3] |
129 | 129 |
130 let lines =<< trim END | 130 let lines =<< trim END |
131 VAR l = [0, 1, 2, 3] | 131 VAR l = [0, 1, 2, 3] |
132 unlet l[2 : 1] | 132 unlet l[2 : 1] |
133 END | 133 END |
134 call CheckLegacyAndVim9Failure(lines, 'E684:') | 134 call v9.CheckLegacyAndVim9Failure(lines, 'E684:') |
135 | 135 |
136 let lines =<< trim END | 136 let lines =<< trim END |
137 VAR l = [0, 1, 2, 3] | 137 VAR l = [0, 1, 2, 3] |
138 unlet l[-1 : 2] | 138 unlet l[-1 : 2] |
139 END | 139 END |
140 call CheckLegacyAndVim9Failure(lines, 'E684:') | 140 call v9.CheckLegacyAndVim9Failure(lines, 'E684:') |
141 endfunc | 141 endfunc |
142 | 142 |
143 " assignment to a list | 143 " assignment to a list |
144 func Test_list_assign() | 144 func Test_list_assign() |
145 let lines =<< trim END | 145 let lines =<< trim END |
147 VAR va = 0 | 147 VAR va = 0 |
148 VAR vb = 0 | 148 VAR vb = 0 |
149 LET [va, vb] = l[2 : 3] | 149 LET [va, vb] = l[2 : 3] |
150 call assert_equal([2, 3], [va, vb]) | 150 call assert_equal([2, 3], [va, vb]) |
151 END | 151 END |
152 call CheckLegacyAndVim9Success(lines) | 152 call v9.CheckLegacyAndVim9Success(lines) |
153 | 153 |
154 let lines =<< trim END | 154 let lines =<< trim END |
155 let l = [0, 1, 2, 3] | 155 let l = [0, 1, 2, 3] |
156 let [va, vb] = l | 156 let [va, vb] = l |
157 END | 157 END |
158 call CheckScriptFailure(lines, 'E687:') | 158 call v9.CheckScriptFailure(lines, 'E687:') |
159 let lines =<< trim END | 159 let lines =<< trim END |
160 var l = [0, 1, 2, 3] | 160 var l = [0, 1, 2, 3] |
161 var va = 0 | 161 var va = 0 |
162 var vb = 0 | 162 var vb = 0 |
163 [va, vb] = l | 163 [va, vb] = l |
164 END | 164 END |
165 call CheckScriptFailure(['vim9script'] + lines, 'E687:') | 165 call v9.CheckScriptFailure(['vim9script'] + lines, 'E687:') |
166 call CheckDefExecFailure(lines, 'E1093: Expected 2 items but got 4') | 166 call v9.CheckDefExecFailure(lines, 'E1093: Expected 2 items but got 4') |
167 | 167 |
168 let lines =<< trim END | 168 let lines =<< trim END |
169 let l = [0, 1, 2, 3] | 169 let l = [0, 1, 2, 3] |
170 let [va, vb] = l[1:1] | 170 let [va, vb] = l[1:1] |
171 END | 171 END |
172 call CheckScriptFailure(lines, 'E688:') | 172 call v9.CheckScriptFailure(lines, 'E688:') |
173 let lines =<< trim END | 173 let lines =<< trim END |
174 var l = [0, 1, 2, 3] | 174 var l = [0, 1, 2, 3] |
175 var va = 0 | 175 var va = 0 |
176 var vb = 0 | 176 var vb = 0 |
177 [va, vb] = l[1 : 1] | 177 [va, vb] = l[1 : 1] |
178 END | 178 END |
179 call CheckScriptFailure(['vim9script'] + lines, 'E688:') | 179 call v9.CheckScriptFailure(['vim9script'] + lines, 'E688:') |
180 call CheckDefExecFailure(lines, 'E1093: Expected 2 items but got 1') | 180 call v9.CheckDefExecFailure(lines, 'E1093: Expected 2 items but got 1') |
181 endfunc | 181 endfunc |
182 | 182 |
183 " test for range assign | 183 " test for range assign |
184 func Test_list_range_assign() | 184 func Test_list_range_assign() |
185 let lines =<< trim END | 185 let lines =<< trim END |
187 LET l[:] = [1, 2] | 187 LET l[:] = [1, 2] |
188 call assert_equal([1, 2], l) | 188 call assert_equal([1, 2], l) |
189 LET l[-4 : -1] = [5, 6] | 189 LET l[-4 : -1] = [5, 6] |
190 call assert_equal([5, 6], l) | 190 call assert_equal([5, 6], l) |
191 END | 191 END |
192 call CheckLegacyAndVim9Success(lines) | 192 call v9.CheckLegacyAndVim9Success(lines) |
193 | 193 |
194 let lines =<< trim END | 194 let lines =<< trim END |
195 var l = [7] | 195 var l = [7] |
196 l[:] = ['text'] | 196 l[:] = ['text'] |
197 END | 197 END |
198 call CheckDefAndScriptFailure(lines, 'E1012:', 2) | 198 call v9.CheckDefAndScriptFailure(lines, 'E1012:', 2) |
199 endfunc | 199 endfunc |
200 | 200 |
201 " Test removing items in list | 201 " Test removing items in list |
202 func Test_list_func_remove() | 202 func Test_list_func_remove() |
203 let lines =<< trim END | 203 let lines =<< trim END |
225 | 225 |
226 LET l = [1, 2, 3, 4] | 226 LET l = [1, 2, 3, 4] |
227 call assert_equal([2, 3], remove(l, -3, -2)) | 227 call assert_equal([2, 3], remove(l, -3, -2)) |
228 call assert_equal([1, 4], l) | 228 call assert_equal([1, 4], l) |
229 END | 229 END |
230 call CheckLegacyAndVim9Success(lines) | 230 call v9.CheckLegacyAndVim9Success(lines) |
231 | 231 |
232 " Test invalid cases | 232 " Test invalid cases |
233 let l = [1, 2, 3, 4] | 233 let l = [1, 2, 3, 4] |
234 call assert_fails("call remove(l, 5)", 'E684:') | 234 call assert_fails("call remove(l, 5)", 'E684:') |
235 call assert_fails("call remove(l, 1, 5)", 'E684:') | 235 call assert_fails("call remove(l, 1, 5)", 'E684:') |
249 call add(l, {'k': 3}) | 249 call add(l, {'k': 3}) |
250 call add(l, {}) | 250 call add(l, {}) |
251 call add(l, test_null_dict()) | 251 call add(l, test_null_dict()) |
252 call assert_equal([1, [2, 3], [], [], {'k': 3}, {}, {}], l) | 252 call assert_equal([1, [2, 3], [], [], {'k': 3}, {}, {}], l) |
253 END | 253 END |
254 call CheckLegacyAndVim9Success(lines) | 254 call v9.CheckLegacyAndVim9Success(lines) |
255 | 255 |
256 " weird legacy behavior | 256 " weird legacy behavior |
257 call assert_equal(1, add(test_null_list(), 4)) | 257 call assert_equal(1, add(test_null_list(), 4)) |
258 endfunc | 258 endfunc |
259 | 259 |
269 call assert_equal(['asd', [1, 2, function('strlen')], {'a': 1}], values(d)) | 269 call assert_equal(['asd', [1, 2, function('strlen')], {'a': 1}], values(d)) |
270 call extend(d, {3: 33, 1: 99}) | 270 call extend(d, {3: 33, 1: 99}) |
271 call extend(d, {'b': 'bbb', 'c': 'ccc'}, "keep") | 271 call extend(d, {'b': 'bbb', 'c': 'ccc'}, "keep") |
272 call assert_equal({'c': 'ccc', '1': 99, 'b': [1, 2, function('strlen')], '3': 33, '-1': {'a': 1}}, d) | 272 call assert_equal({'c': 'ccc', '1': 99, 'b': [1, 2, function('strlen')], '3': 33, '-1': {'a': 1}}, d) |
273 END | 273 END |
274 call CheckLegacyAndVim9Success(lines) | 274 call v9.CheckLegacyAndVim9Success(lines) |
275 | 275 |
276 let d = {001: 'asd', 'b': [1, 2, function('strlen')], -1: {'a': 1},} | 276 let d = {001: 'asd', 'b': [1, 2, function('strlen')], -1: {'a': 1},} |
277 call assert_equal("{'1': 'asd', 'b': [1, 2, function('strlen')], '-1': {'a': 1}}", string(d)) | 277 call assert_equal("{'1': 'asd', 'b': [1, 2, function('strlen')], '-1': {'a': 1}}", string(d)) |
278 | 278 |
279 let v = [] | 279 let v = [] |
318 call assert_true(d is dd) | 318 call assert_true(d is dd) |
319 call assert_true(d == dx) | 319 call assert_true(d == dx) |
320 call assert_false(d is dx) | 320 call assert_false(d is dx) |
321 call assert_true(d isnot dx) | 321 call assert_true(d isnot dx) |
322 END | 322 END |
323 call CheckLegacyAndVim9Success(lines) | 323 call v9.CheckLegacyAndVim9Success(lines) |
324 endfunc | 324 endfunc |
325 | 325 |
326 " removing items with :unlet | 326 " removing items with :unlet |
327 func Test_dict_unlet() | 327 func Test_dict_unlet() |
328 let lines =<< trim END | 328 let lines =<< trim END |
329 VAR d = {'b': 'bbb', '1': 99, '3': 33, '-1': {'a': 1}} | 329 VAR d = {'b': 'bbb', '1': 99, '3': 33, '-1': {'a': 1}} |
330 unlet d.b | 330 unlet d.b |
331 unlet d[-1] | 331 unlet d[-1] |
332 call assert_equal({'1': 99, '3': 33}, d) | 332 call assert_equal({'1': 99, '3': 33}, d) |
333 END | 333 END |
334 call CheckLegacyAndVim9Success(lines) | 334 call v9.CheckLegacyAndVim9Success(lines) |
335 endfunc | 335 endfunc |
336 | 336 |
337 " manipulating a big Dictionary (hashtable.c has a border of 1000 entries) | 337 " manipulating a big Dictionary (hashtable.c has a border of 1000 entries) |
338 func Test_dict_big() | 338 func Test_dict_big() |
339 let d = {} | 339 let d = {} |
403 VAR d = {} | 403 VAR d = {} |
404 LET d.a = 1 | 404 LET d.a = 1 |
405 LET d._ = 2 | 405 LET d._ = 2 |
406 call assert_equal({'a': 1, '_': 2}, d) | 406 call assert_equal({'a': 1, '_': 2}, d) |
407 END | 407 END |
408 call CheckLegacyAndVim9Success(lines) | 408 call v9.CheckLegacyAndVim9Success(lines) |
409 | 409 |
410 let lines =<< trim END | 410 let lines =<< trim END |
411 let n = 0 | 411 let n = 0 |
412 let n.key = 3 | 412 let n.key = 3 |
413 END | 413 END |
414 call CheckScriptFailure(lines, 'E1203: Dot can only be used on a dictionary: n.key = 3') | 414 call v9.CheckScriptFailure(lines, 'E1203: Dot can only be used on a dictionary: n.key = 3') |
415 let lines =<< trim END | 415 let lines =<< trim END |
416 vim9script | 416 vim9script |
417 var n = 0 | 417 var n = 0 |
418 n.key = 3 | 418 n.key = 3 |
419 END | 419 END |
420 call CheckScriptFailure(lines, 'E1203: Dot can only be used on a dictionary: n.key = 3') | 420 call v9.CheckScriptFailure(lines, 'E1203: Dot can only be used on a dictionary: n.key = 3') |
421 let lines =<< trim END | 421 let lines =<< trim END |
422 var n = 0 | 422 var n = 0 |
423 n.key = 3 | 423 n.key = 3 |
424 END | 424 END |
425 call CheckDefFailure(lines, 'E1141:') | 425 call v9.CheckDefFailure(lines, 'E1141:') |
426 endfunc | 426 endfunc |
427 | 427 |
428 " Function in script-local List or Dict | 428 " Function in script-local List or Dict |
429 func Test_script_local_dict_func() | 429 func Test_script_local_dict_func() |
430 let g:dict = {} | 430 let g:dict = {} |
442 let lines =<< trim END | 442 let lines =<< trim END |
443 VAR d = {1: 'a', 2: 'b', 3: 'c'} | 443 VAR d = {1: 'a', 2: 'b', 3: 'c'} |
444 call assert_equal('b', remove(d, 2)) | 444 call assert_equal('b', remove(d, 2)) |
445 call assert_equal({1: 'a', 3: 'c'}, d) | 445 call assert_equal({1: 'a', 3: 'c'}, d) |
446 END | 446 END |
447 call CheckLegacyAndVim9Success(lines) | 447 call v9.CheckLegacyAndVim9Success(lines) |
448 | 448 |
449 let lines =<< trim END | 449 let lines =<< trim END |
450 VAR d = {1: 'a', 3: 'c'} | 450 VAR d = {1: 'a', 3: 'c'} |
451 call remove(d, 1, 2) | 451 call remove(d, 1, 2) |
452 END | 452 END |
453 call CheckLegacyAndVim9Failure(lines, 'E118:') | 453 call v9.CheckLegacyAndVim9Failure(lines, 'E118:') |
454 | 454 |
455 let lines =<< trim END | 455 let lines =<< trim END |
456 VAR d = {1: 'a', 3: 'c'} | 456 VAR d = {1: 'a', 3: 'c'} |
457 call remove(d, 'a') | 457 call remove(d, 'a') |
458 END | 458 END |
459 call CheckLegacyAndVim9Failure(lines, 'E716:') | 459 call v9.CheckLegacyAndVim9Failure(lines, 'E716:') |
460 | 460 |
461 let lines =<< trim END | 461 let lines =<< trim END |
462 let d = {'a-b': 55} | 462 let d = {'a-b': 55} |
463 echo d.a-b | 463 echo d.a-b |
464 END | 464 END |
465 call CheckScriptFailure(lines, 'E716: Key not present in Dictionary: "a"') | 465 call v9.CheckScriptFailure(lines, 'E716: Key not present in Dictionary: "a"') |
466 | 466 |
467 let lines =<< trim END | 467 let lines =<< trim END |
468 vim9script | 468 vim9script |
469 var d = {'a-b': 55} | 469 var d = {'a-b': 55} |
470 echo d.a-b | 470 echo d.a-b |
471 END | 471 END |
472 call CheckScriptFailure(lines, 'E716: Key not present in Dictionary: "a"') | 472 call v9.CheckScriptFailure(lines, 'E716: Key not present in Dictionary: "a"') |
473 | 473 |
474 let lines =<< trim END | 474 let lines =<< trim END |
475 var d = {'a-b': 55} | 475 var d = {'a-b': 55} |
476 echo d.a-b | 476 echo d.a-b |
477 END | 477 END |
478 call CheckDefFailure(lines, 'E1004: White space required before and after ''-''') | 478 call v9.CheckDefFailure(lines, 'E1004: White space required before and after ''-''') |
479 | 479 |
480 let lines =<< trim END | 480 let lines =<< trim END |
481 let d = {1: 'a', 3: 'c'} | 481 let d = {1: 'a', 3: 'c'} |
482 call remove(d, []) | 482 call remove(d, []) |
483 END | 483 END |
484 call CheckScriptFailure(lines, 'E730:') | 484 call v9.CheckScriptFailure(lines, 'E730:') |
485 let lines =<< trim END | 485 let lines =<< trim END |
486 vim9script | 486 vim9script |
487 var d = {1: 'a', 3: 'c'} | 487 var d = {1: 'a', 3: 'c'} |
488 call remove(d, []) | 488 call remove(d, []) |
489 END | 489 END |
490 call CheckScriptFailure(lines, 'E1220: String or Number required for argument 2') | 490 call v9.CheckScriptFailure(lines, 'E1220: String or Number required for argument 2') |
491 let lines =<< trim END | 491 let lines =<< trim END |
492 var d = {1: 'a', 3: 'c'} | 492 var d = {1: 'a', 3: 'c'} |
493 call remove(d, []) | 493 call remove(d, []) |
494 END | 494 END |
495 call CheckDefExecFailure(lines, 'E1013: Argument 2: type mismatch, expected string but got list<unknown>') | 495 call v9.CheckDefExecFailure(lines, 'E1013: Argument 2: type mismatch, expected string but got list<unknown>') |
496 endfunc | 496 endfunc |
497 | 497 |
498 " Nasty: remove func from Dict that's being called (works) | 498 " Nasty: remove func from Dict that's being called (works) |
499 func Test_dict_func_remove_in_use() | 499 func Test_dict_func_remove_in_use() |
500 let d = {1:1} | 500 let d = {1:1} |
512 endfunc | 512 endfunc |
513 LET d.func = function('GetArg') | 513 LET d.func = function('GetArg') |
514 VAR expected = 'a:' .. string(get(d, 'func')) | 514 VAR expected = 'a:' .. string(get(d, 'func')) |
515 call assert_equal(expected, d.func(string(remove(d, 'func')))) | 515 call assert_equal(expected, d.func(string(remove(d, 'func')))) |
516 END | 516 END |
517 call CheckTransLegacySuccess(lines) | 517 call v9.CheckTransLegacySuccess(lines) |
518 call CheckTransVim9Success(lines) | 518 call v9.CheckTransVim9Success(lines) |
519 endfunc | 519 endfunc |
520 | 520 |
521 func Test_dict_literal_keys() | 521 func Test_dict_literal_keys() |
522 call assert_equal({'one': 1, 'two2': 2, '3three': 3, '44': 4}, #{one: 1, two2: 2, 3three: 3, 44: 4},) | 522 call assert_equal({'one': 1, 'two2': 2, '3three': 3, '44': 4}, #{one: 1, two2: 2, 3three: 3, 44: 4},) |
523 | 523 |
533 VAR l = [4, d, 6] | 533 VAR l = [4, d, 6] |
534 LET d[3] = l | 534 LET d[3] = l |
535 VAR dc = deepcopy(d) | 535 VAR dc = deepcopy(d) |
536 call deepcopy(d, 1) | 536 call deepcopy(d, 1) |
537 END | 537 END |
538 call CheckLegacyAndVim9Failure(lines, 'E698:') | 538 call v9.CheckLegacyAndVim9Failure(lines, 'E698:') |
539 | 539 |
540 let lines =<< trim END | 540 let lines =<< trim END |
541 VAR d = {1: 1, 2: '2'} | 541 VAR d = {1: 1, 2: '2'} |
542 VAR l = [4, d, 6] | 542 VAR l = [4, d, 6] |
543 LET d[3] = l | 543 LET d[3] = l |
544 VAR l2 = [0, l, l, 3] | 544 VAR l2 = [0, l, l, 3] |
545 LET l[1] = l2 | 545 LET l[1] = l2 |
546 VAR l3 = deepcopy(l2) | 546 VAR l3 = deepcopy(l2) |
547 call assert_true(l3[1] is l3[2]) | 547 call assert_true(l3[1] is l3[2]) |
548 END | 548 END |
549 call CheckLegacyAndVim9Success(lines) | 549 call v9.CheckLegacyAndVim9Success(lines) |
550 | 550 |
551 call assert_fails("call deepcopy([1, 2], 2)", 'E1023:') | 551 call assert_fails("call deepcopy([1, 2], 2)", 'E1023:') |
552 endfunc | 552 endfunc |
553 | 553 |
554 " Locked variables | 554 " Locked variables |
629 call assert_equal(expected[depth][u][1], ps, 'depth: ' .. depth) | 629 call assert_equal(expected[depth][u][1], ps, 'depth: ' .. depth) |
630 unlock! l | 630 unlock! l |
631 endfor | 631 endfor |
632 endfor | 632 endfor |
633 END | 633 END |
634 call CheckTransLegacySuccess(lines) | 634 call v9.CheckTransLegacySuccess(lines) |
635 call CheckTransVim9Success(lines) | 635 call v9.CheckTransVim9Success(lines) |
636 | 636 |
637 call assert_fails("let x=islocked('a b')", 'E488:') | 637 call assert_fails("let x=islocked('a b')", 'E488:') |
638 let mylist = [1, 2, 3] | 638 let mylist = [1, 2, 3] |
639 call assert_fails("let x = islocked('mylist[1:2]')", 'E786:') | 639 call assert_fails("let x = islocked('mylist[1:2]')", 'E786:') |
640 let mydict = {'k' : 'v'} | 640 let mydict = {'k' : 'v'} |
743 VAR d = {'a': 99, 'b': 100} | 743 VAR d = {'a': 99, 'b': 100} |
744 lockvar d.a | 744 lockvar d.a |
745 unlet d.a | 745 unlet d.a |
746 call assert_equal({'b': 100}, d) | 746 call assert_equal({'b': 100}, d) |
747 END | 747 END |
748 call CheckLegacyAndVim9Success(lines) | 748 call v9.CheckLegacyAndVim9Success(lines) |
749 endfunc | 749 endfunc |
750 | 750 |
751 " filter() after lock on dict item | 751 " filter() after lock on dict item |
752 func Test_dict_lock_filter() | 752 func Test_dict_lock_filter() |
753 let lines =<< trim END | 753 let lines =<< trim END |
754 VAR d = {'a': 99, 'b': 100} | 754 VAR d = {'a': 99, 'b': 100} |
755 lockvar d.a | 755 lockvar d.a |
756 call filter(d, 'v:key != "a"') | 756 call filter(d, 'v:key != "a"') |
757 call assert_equal({'b': 100}, d) | 757 call assert_equal({'b': 100}, d) |
758 END | 758 END |
759 call CheckLegacyAndVim9Success(lines) | 759 call v9.CheckLegacyAndVim9Success(lines) |
760 endfunc | 760 endfunc |
761 | 761 |
762 " map() after lock on dict | 762 " map() after lock on dict |
763 func Test_dict_lock_map() | 763 func Test_dict_lock_map() |
764 let lines =<< trim END | 764 let lines =<< trim END |
766 lockvar 1 d | 766 lockvar 1 d |
767 call map(d, 'v:val + 200') | 767 call map(d, 'v:val + 200') |
768 call assert_equal({'a': 299, 'b': 300}, d) | 768 call assert_equal({'a': 299, 'b': 300}, d) |
769 END | 769 END |
770 " This won't work in a :def function | 770 " This won't work in a :def function |
771 call CheckTransLegacySuccess(lines) | 771 call v9.CheckTransLegacySuccess(lines) |
772 call CheckTransVim9Success(lines) | 772 call v9.CheckTransVim9Success(lines) |
773 | 773 |
774 " For a :def function use a global dict. | 774 " For a :def function use a global dict. |
775 let lines =<< trim END | 775 let lines =<< trim END |
776 let g:thedict = {'a': 77, 'b': 88} | 776 let g:thedict = {'a': 77, 'b': 88} |
777 lockvar 1 g:thedict | 777 lockvar 1 g:thedict |
778 def Delkey() | 778 def Delkey() |
779 unlet g:thedict.a | 779 unlet g:thedict.a |
780 enddef | 780 enddef |
781 call Delkey() | 781 call Delkey() |
782 END | 782 END |
783 call CheckScriptFailure(lines, 'E741:') | 783 call v9.CheckScriptFailure(lines, 'E741:') |
784 endfunc | 784 endfunc |
785 | 785 |
786 " Lock one item in a list | 786 " Lock one item in a list |
787 func Test_list_item_lock_map() | 787 func Test_list_item_lock_map() |
788 let lines =<< trim END | 788 let lines =<< trim END |
790 lockvar l[1] | 790 lockvar l[1] |
791 call assert_fails("echo map(l, 'v:val + 200')", 'E741:') | 791 call assert_fails("echo map(l, 'v:val + 200')", 'E741:') |
792 call assert_equal([299, 100, 101], l) | 792 call assert_equal([299, 100, 101], l) |
793 END | 793 END |
794 " This won't work in a :def function | 794 " This won't work in a :def function |
795 call CheckTransLegacySuccess(lines) | 795 call v9.CheckTransLegacySuccess(lines) |
796 call CheckTransVim9Success(lines) | 796 call v9.CheckTransVim9Success(lines) |
797 endfunc | 797 endfunc |
798 | 798 |
799 " Lock one item in a dict | 799 " Lock one item in a dict |
800 func Test_dict_item_lock_map() | 800 func Test_dict_item_lock_map() |
801 let lines =<< trim END | 801 let lines =<< trim END |
803 lockvar d.b | 803 lockvar d.b |
804 call assert_fails("echo map(d, 'v:val + 200')", 'E741:') | 804 call assert_fails("echo map(d, 'v:val + 200')", 'E741:') |
805 call assert_equal({'a': 299, 'b': 100, 'c': 101}, d) | 805 call assert_equal({'a': 299, 'b': 100, 'c': 101}, d) |
806 END | 806 END |
807 " This won't work in a :def function | 807 " This won't work in a :def function |
808 call CheckTransLegacySuccess(lines) | 808 call v9.CheckTransLegacySuccess(lines) |
809 call CheckTransVim9Success(lines) | 809 call v9.CheckTransVim9Success(lines) |
810 endfunc | 810 endfunc |
811 | 811 |
812 " No extend() after lock on dict item | 812 " No extend() after lock on dict item |
813 func Test_dict_lock_extend() | 813 func Test_dict_lock_extend() |
814 let d = {'a': 99, 'b': 100} | 814 let d = {'a': 99, 'b': 100} |
883 enddef | 883 enddef |
884 let l = [1, 2, 3, 4] | 884 let l = [1, 2, 3, 4] |
885 lockvar! l | 885 lockvar! l |
886 call TryUnletListItem(l) | 886 call TryUnletListItem(l) |
887 END | 887 END |
888 call CheckScriptFailure(lines, 'E741:') | 888 call v9.CheckScriptFailure(lines, 'E741:') |
889 unlet g:l | 889 unlet g:l |
890 endfunc | 890 endfunc |
891 | 891 |
892 " Locking part of the list | 892 " Locking part of the list |
893 func Test_let_lock_list_items() | 893 func Test_let_lock_list_items() |
952 call assert_equal(['bar', 'BAR', 'Bar', 'Foo', 'FOO', 'foo', 'FOOBAR', -1, 0, 0, 0.22, 1.0e-15, 12, 18, 22, 255, 7, 9, [], {}], sort(copy(l), 1)) | 952 call assert_equal(['bar', 'BAR', 'Bar', 'Foo', 'FOO', 'foo', 'FOOBAR', -1, 0, 0, 0.22, 1.0e-15, 12, 18, 22, 255, 7, 9, [], {}], sort(copy(l), 1)) |
953 call assert_equal(['bar', 'BAR', 'Bar', 'Foo', 'FOO', 'foo', 'FOOBAR', -1, 0, 0, 0.22, 1.0e-15, 12, 18, 22, 255, 7, 9, [], {}], sort(copy(l), 'i')) | 953 call assert_equal(['bar', 'BAR', 'Bar', 'Foo', 'FOO', 'foo', 'FOOBAR', -1, 0, 0, 0.22, 1.0e-15, 12, 18, 22, 255, 7, 9, [], {}], sort(copy(l), 'i')) |
954 call assert_equal(['BAR', 'Bar', 'FOO', 'FOOBAR', 'Foo', 'bar', 'foo', -1, 0, 0, 0.22, 1.0e-15, 12, 18, 22, 255, 7, 9, [], {}], sort(copy(l))) | 954 call assert_equal(['BAR', 'Bar', 'FOO', 'FOOBAR', 'Foo', 'bar', 'foo', -1, 0, 0, 0.22, 1.0e-15, 12, 18, 22, 255, 7, 9, [], {}], sort(copy(l))) |
955 endif | 955 endif |
956 END | 956 END |
957 call CheckLegacyAndVim9Success(lines) | 957 call v9.CheckLegacyAndVim9Success(lines) |
958 | 958 |
959 call assert_fails('call reverse("")', 'E899:') | 959 call assert_fails('call reverse("")', 'E899:') |
960 call assert_fails('call uniq([1, 2], {x, y -> []})', 'E745:') | 960 call assert_fails('call uniq([1, 2], {x, y -> []})', 'E745:') |
961 call assert_fails("call sort([1, 2], function('min'), 1)", "E715:") | 961 call assert_fails("call sort([1, 2], function('min'), 1)", "E715:") |
962 call assert_fails("call sort([1, 2], function('invalid_func'))", "E700:") | 962 call assert_fails("call sort([1, 2], function('invalid_func'))", "E700:") |
995 call assert_equal('c,à,t', reduce('càt', LSTART acc, val LMIDDLE acc .. ',' .. val LEND)) | 995 call assert_equal('c,à,t', reduce('càt', LSTART acc, val LMIDDLE acc .. ',' .. val LEND)) |
996 call assert_equal('Å,s,t,r,ö,m', reduce('Åström', LSTART acc, val LMIDDLE acc .. ',' .. val LEND)) | 996 call assert_equal('Å,s,t,r,ö,m', reduce('Åström', LSTART acc, val LMIDDLE acc .. ',' .. val LEND)) |
997 call assert_equal('Å,s,t,r,ö,m', reduce('Åström', LSTART acc, val LMIDDLE acc .. ',' .. val LEND)) | 997 call assert_equal('Å,s,t,r,ö,m', reduce('Åström', LSTART acc, val LMIDDLE acc .. ',' .. val LEND)) |
998 call assert_equal(',a,b,c', reduce('abc', LSTART acc, val LMIDDLE acc .. ',' .. val LEND, test_null_string())) | 998 call assert_equal(',a,b,c', reduce('abc', LSTART acc, val LMIDDLE acc .. ',' .. val LEND, test_null_string())) |
999 END | 999 END |
1000 call CheckLegacyAndVim9Success(lines) | 1000 call v9.CheckLegacyAndVim9Success(lines) |
1001 | 1001 |
1002 call assert_equal({'x': 1, 'y': 1, 'z': 1 }, ['x', 'y', 'z']->reduce({ acc, val -> extend(acc, { val: 1 }) }, {})) | 1002 call assert_equal({'x': 1, 'y': 1, 'z': 1 }, ['x', 'y', 'z']->reduce({ acc, val -> extend(acc, { val: 1 }) }, {})) |
1003 vim9 assert_equal({'x': 1, 'y': 1, 'z': 1 }, ['x', 'y', 'z']->reduce((acc, val) => extend(acc, {[val]: 1 }), {})) | 1003 vim9 assert_equal({'x': 1, 'y': 1, 'z': 1 }, ['x', 'y', 'z']->reduce((acc, val) => extend(acc, {[val]: 1 }), {})) |
1004 | 1004 |
1005 call assert_fails("call reduce([], { acc, val -> acc + val })", 'E998: Reduce of an empty List with no initial value') | 1005 call assert_fails("call reduce([], { acc, val -> acc + val })", 'E998: Reduce of an empty List with no initial value') |
1053 call assert_equal(['aa', '', 'bb', 'cc', ''], split('aa,,bb, cc,', ',\s*', 1)) | 1053 call assert_equal(['aa', '', 'bb', 'cc', ''], split('aa,,bb, cc,', ',\s*', 1)) |
1054 call assert_equal(['a', 'b', 'c'], split('abc', '\zs')) | 1054 call assert_equal(['a', 'b', 'c'], split('abc', '\zs')) |
1055 call assert_equal(['', 'a', '', 'b', '', 'c', ''], split('abc', '\zs', 1)) | 1055 call assert_equal(['', 'a', '', 'b', '', 'c', ''], split('abc', '\zs', 1)) |
1056 call assert_equal(['abc'], split('abc', '\\%(')) | 1056 call assert_equal(['abc'], split('abc', '\\%(')) |
1057 END | 1057 END |
1058 call CheckLegacyAndVim9Success(lines) | 1058 call v9.CheckLegacyAndVim9Success(lines) |
1059 | 1059 |
1060 call assert_fails("call split('abc', [])", 'E730:') | 1060 call assert_fails("call split('abc', [])", 'E730:') |
1061 call assert_fails("call split('abc', 'b', [])", 'E745:') | 1061 call assert_fails("call split('abc', 'b', [])", 'E745:') |
1062 endfunc | 1062 endfunc |
1063 | 1063 |
1070 call assert_true(l == l) | 1070 call assert_true(l == l) |
1071 call assert_true(d == d) | 1071 call assert_true(d == d) |
1072 call assert_false(l != deepcopy(l)) | 1072 call assert_false(l != deepcopy(l)) |
1073 call assert_false(d != deepcopy(d)) | 1073 call assert_false(d != deepcopy(d)) |
1074 END | 1074 END |
1075 call CheckLegacyAndVim9Success(lines) | 1075 call v9.CheckLegacyAndVim9Success(lines) |
1076 | 1076 |
1077 " comparison errors | 1077 " comparison errors |
1078 call assert_fails('echo [1, 2] =~ {}', 'E691:') | 1078 call assert_fails('echo [1, 2] =~ {}', 'E691:') |
1079 call assert_fails('echo [1, 2] =~ [1, 2]', 'E692:') | 1079 call assert_fails('echo [1, 2] =~ [1, 2]', 'E692:') |
1080 call assert_fails('echo {} =~ 5', 'E735:') | 1080 call assert_fails('echo {} =~ 5', 'E735:') |
1091 VAR lcopy = deepcopy(l) | 1091 VAR lcopy = deepcopy(l) |
1092 VAR dict4copy = deepcopy(dict4) | 1092 VAR dict4copy = deepcopy(dict4) |
1093 call assert_true(l == lcopy) | 1093 call assert_true(l == lcopy) |
1094 call assert_true(dict4 == dict4copy) | 1094 call assert_true(dict4 == dict4copy) |
1095 END | 1095 END |
1096 call CheckLegacyAndVim9Success(lines) | 1096 call v9.CheckLegacyAndVim9Success(lines) |
1097 endfunc | 1097 endfunc |
1098 | 1098 |
1099 " Test for extending lists and dictionaries | 1099 " Test for extending lists and dictionaries |
1100 func Test_listdict_extend() | 1100 func Test_listdict_extend() |
1101 " Test extend() with lists | 1101 " Test extend() with lists |
1128 | 1128 |
1129 LET l = [1, 2, 3] | 1129 LET l = [1, 2, 3] |
1130 call extend(l, [4, 5, 6], -3) | 1130 call extend(l, [4, 5, 6], -3) |
1131 call assert_equal([4, 5, 6, 1, 2, 3], l) | 1131 call assert_equal([4, 5, 6, 1, 2, 3], l) |
1132 END | 1132 END |
1133 call CheckLegacyAndVim9Success(lines) | 1133 call v9.CheckLegacyAndVim9Success(lines) |
1134 | 1134 |
1135 let l = [1, 2, 3] | 1135 let l = [1, 2, 3] |
1136 call assert_fails("call extend(l, [4, 5, 6], 4)", 'E684:') | 1136 call assert_fails("call extend(l, [4, 5, 6], 4)", 'E684:') |
1137 call assert_fails("call extend(l, [4, 5, 6], -4)", 'E684:') | 1137 call assert_fails("call extend(l, [4, 5, 6], -4)", 'E684:') |
1138 if has('float') | 1138 if has('float') |
1157 | 1157 |
1158 LET d = {'a': 'A', 'b': 9} | 1158 LET d = {'a': 'A', 'b': 9} |
1159 call extend(d, {'b': 0, 'c': 'C'}, "keep") | 1159 call extend(d, {'b': 0, 'c': 'C'}, "keep") |
1160 call assert_equal({'a': 'A', 'b': 9, 'c': 'C'}, d) | 1160 call assert_equal({'a': 'A', 'b': 9, 'c': 'C'}, d) |
1161 END | 1161 END |
1162 call CheckLegacyAndVim9Success(lines) | 1162 call v9.CheckLegacyAndVim9Success(lines) |
1163 | 1163 |
1164 let d = {'a': 'A', 'b': 'B'} | 1164 let d = {'a': 'A', 'b': 'B'} |
1165 call assert_fails("call extend(d, {'b': 0, 'c':'C'}, 'error')", 'E737:') | 1165 call assert_fails("call extend(d, {'b': 0, 'c':'C'}, 'error')", 'E737:') |
1166 call assert_fails("call extend(d, {'b': 0}, [])", 'E730:') | 1166 call assert_fails("call extend(d, {'b': 0}, [])", 'E730:') |
1167 call assert_fails("call extend(d, {'b': 0, 'c':'C'}, 'xxx')", 'E475:') | 1167 call assert_fails("call extend(d, {'b': 0, 'c':'C'}, 'xxx')", 'E475:') |
1189 call assert_equal([1, 5, 1, 5, 7, 7], l) | 1189 call assert_equal([1, 5, 1, 5, 7, 7], l) |
1190 LET l = [1, 5, 7] | 1190 LET l = [1, 5, 7] |
1191 call extend(l, l, 3) | 1191 call extend(l, l, 3) |
1192 call assert_equal([1, 5, 7, 1, 5, 7], l) | 1192 call assert_equal([1, 5, 7, 1, 5, 7], l) |
1193 END | 1193 END |
1194 call CheckLegacyAndVim9Success(lines) | 1194 call v9.CheckLegacyAndVim9Success(lines) |
1195 endfunc | 1195 endfunc |
1196 | 1196 |
1197 func Test_listdict_extendnew() | 1197 func Test_listdict_extendnew() |
1198 " Test extendnew() with lists | 1198 " Test extendnew() with lists |
1199 let l = [1, 2, 3] | 1199 let l = [1, 2, 3] |
1316 unlet deep_dict | 1316 unlet deep_dict |
1317 endfunc | 1317 endfunc |
1318 | 1318 |
1319 " List and dict indexing tests | 1319 " List and dict indexing tests |
1320 func Test_listdict_index() | 1320 func Test_listdict_index() |
1321 call CheckLegacyAndVim9Failure(['echo function("min")[0]'], 'E695:') | 1321 call v9.CheckLegacyAndVim9Failure(['echo function("min")[0]'], 'E695:') |
1322 call CheckLegacyAndVim9Failure(['echo v:true[0]'], 'E909:') | 1322 call v9.CheckLegacyAndVim9Failure(['echo v:true[0]'], 'E909:') |
1323 call CheckLegacyAndVim9Failure(['echo v:null[0]'], 'E909:') | 1323 call v9.CheckLegacyAndVim9Failure(['echo v:null[0]'], 'E909:') |
1324 call CheckLegacyAndVim9Failure(['VAR d = {"k": 10}', 'echo d.'], ['E15:', 'E1127:', 'E15:']) | 1324 call v9.CheckLegacyAndVim9Failure(['VAR d = {"k": 10}', 'echo d.'], ['E15:', 'E1127:', 'E15:']) |
1325 call CheckLegacyAndVim9Failure(['VAR d = {"k": 10}', 'echo d[1 : 2]'], 'E719:') | 1325 call v9.CheckLegacyAndVim9Failure(['VAR d = {"k": 10}', 'echo d[1 : 2]'], 'E719:') |
1326 | 1326 |
1327 call assert_fails("let v = [4, 6][{-> 1}]", 'E729:') | 1327 call assert_fails("let v = [4, 6][{-> 1}]", 'E729:') |
1328 call CheckDefAndScriptFailure(['var v = [4, 6][() => 1]'], ['E1012', 'E703:']) | 1328 call v9.CheckDefAndScriptFailure(['var v = [4, 6][() => 1]'], ['E1012', 'E703:']) |
1329 | 1329 |
1330 call CheckLegacyAndVim9Failure(['VAR v = range(5)[2 : []]'], ['E730:', 'E1012:', 'E730:']) | 1330 call v9.CheckLegacyAndVim9Failure(['VAR v = range(5)[2 : []]'], ['E730:', 'E1012:', 'E730:']) |
1331 | 1331 |
1332 call assert_fails("let v = range(5)[2:{-> 2}(]", ['E15:', 'E116:']) | 1332 call assert_fails("let v = range(5)[2:{-> 2}(]", ['E15:', 'E116:']) |
1333 call CheckDefAndScriptFailure(['var v = range(5)[2 : () => 2(]'], 'E15:') | 1333 call v9.CheckDefAndScriptFailure(['var v = range(5)[2 : () => 2(]'], 'E15:') |
1334 | 1334 |
1335 call CheckLegacyAndVim9Failure(['VAR v = range(5)[2 : 3'], ['E111:', 'E1097:', 'E111:']) | 1335 call v9.CheckLegacyAndVim9Failure(['VAR v = range(5)[2 : 3'], ['E111:', 'E1097:', 'E111:']) |
1336 call CheckLegacyAndVim9Failure(['VAR l = insert([1, 2, 3], 4, 10)'], 'E684:') | 1336 call v9.CheckLegacyAndVim9Failure(['VAR l = insert([1, 2, 3], 4, 10)'], 'E684:') |
1337 call CheckLegacyAndVim9Failure(['VAR l = insert([1, 2, 3], 4, -10)'], 'E684:') | 1337 call v9.CheckLegacyAndVim9Failure(['VAR l = insert([1, 2, 3], 4, -10)'], 'E684:') |
1338 call CheckLegacyAndVim9Failure(['VAR l = insert([1, 2, 3], 4, [])'], ['E745:', 'E1013:', 'E1210:']) | 1338 call v9.CheckLegacyAndVim9Failure(['VAR l = insert([1, 2, 3], 4, [])'], ['E745:', 'E1013:', 'E1210:']) |
1339 | 1339 |
1340 call CheckLegacyAndVim9Failure(['VAR l = [1, 2, 3]', 'LET l[i] = 3'], ['E121:', 'E1001:', 'E121:']) | 1340 call v9.CheckLegacyAndVim9Failure(['VAR l = [1, 2, 3]', 'LET l[i] = 3'], ['E121:', 'E1001:', 'E121:']) |
1341 call CheckLegacyAndVim9Failure(['VAR l = [1, 2, 3]', 'LET l[1.1] = 4'], ['E805:', 'E1012:', 'E805:']) | 1341 call v9.CheckLegacyAndVim9Failure(['VAR l = [1, 2, 3]', 'LET l[1.1] = 4'], ['E805:', 'E1012:', 'E805:']) |
1342 call CheckLegacyAndVim9Failure(['VAR l = [1, 2, 3]', 'LET l[: i] = [4, 5]'], ['E121:', 'E1001:', 'E121:']) | 1342 call v9.CheckLegacyAndVim9Failure(['VAR l = [1, 2, 3]', 'LET l[: i] = [4, 5]'], ['E121:', 'E1001:', 'E121:']) |
1343 call CheckLegacyAndVim9Failure(['VAR l = [1, 2, 3]', 'LET l[: 3.2] = [4, 5]'], ['E805:', 'E1012:', 'E805:']) | 1343 call v9.CheckLegacyAndVim9Failure(['VAR l = [1, 2, 3]', 'LET l[: 3.2] = [4, 5]'], ['E805:', 'E1012:', 'E805:']) |
1344 call CheckLegacyAndVim9Failure(['VAR t = test_unknown()', 'echo t[0]'], 'E685:') | 1344 call v9.CheckLegacyAndVim9Failure(['VAR t = test_unknown()', 'echo t[0]'], 'E685:') |
1345 endfunc | 1345 endfunc |
1346 | 1346 |
1347 " Test for a null list | 1347 " Test for a null list |
1348 func Test_null_list() | 1348 func Test_null_list() |
1349 let lines =<< trim END | 1349 let lines =<< trim END |
1377 call assert_equal([], reverse(l)) | 1377 call assert_equal([], reverse(l)) |
1378 call assert_equal([], sort(test_null_list())) | 1378 call assert_equal([], sort(test_null_list())) |
1379 call assert_equal([], sort(l)) | 1379 call assert_equal([], sort(l)) |
1380 call assert_equal('[]', string(l)) | 1380 call assert_equal('[]', string(l)) |
1381 END | 1381 END |
1382 call CheckLegacyAndVim9Success(lines) | 1382 call v9.CheckLegacyAndVim9Success(lines) |
1383 | 1383 |
1384 let l = test_null_list() | 1384 let l = test_null_list() |
1385 call assert_equal([], extend(l, l, 0)) | 1385 call assert_equal([], extend(l, l, 0)) |
1386 call assert_equal(0, insert(test_null_list(), 2, -1)) | 1386 call assert_equal(0, insert(test_null_list(), 2, -1)) |
1387 call assert_fails('let s = join([1, 2], [])', 'E730:') | 1387 call assert_fails('let s = join([1, 2], [])', 'E730:') |
1418 call assert_equal(0, min(d)) | 1418 call assert_equal(0, min(d)) |
1419 call assert_equal(0, max(d)) | 1419 call assert_equal(0, max(d)) |
1420 call assert_equal(0, remove(test_null_dict(), 'k')) | 1420 call assert_equal(0, remove(test_null_dict(), 'k')) |
1421 call assert_equal('{}', string(d)) | 1421 call assert_equal('{}', string(d)) |
1422 END | 1422 END |
1423 call CheckLegacyAndVim9Success(lines) | 1423 call v9.CheckLegacyAndVim9Success(lines) |
1424 | 1424 |
1425 let d = test_null_dict() | 1425 let d = test_null_dict() |
1426 call assert_equal({}, extend(d, d, 'keep')) | 1426 call assert_equal({}, extend(d, d, 'keep')) |
1427 call assert_fails("call remove(d, 'k')", 'E716:') | 1427 call assert_fails("call remove(d, 'k')", 'E716:') |
1428 call assert_fails('let x = d[10]', 'E716:') | 1428 call assert_fails('let x = d[10]', 'E716:') |