Mercurial > vim

comparison src/testdir/test_eval_stuff.vim @ 29525:5063dfe96a59 v9.0.0104

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
patch 9.0.0104: going beyond allocated memory when evaluating string constant Commit: https://github.com/vim/vim/commit/1e56bda9048a9625bce6e660938c834c5c15b07d Author: Bram Moolenaar <Bram@vim.org> Date: Fri Jul 29 15:28:27 2022 +0100 patch 9.0.0104: going beyond allocated memory when evaluating string constant Problem: Going beyond allocated memory when evaluating string constant. Solution: Properly skip over <Key> form.
author Bram Moolenaar <Bram@vim.org>
date Fri, 29 Jul 2022 16:30:04 +0200
parents 53c608c7ea9e
children 0cea0cdcce92
comparison
equal deleted inserted replaced
29524:db3afe53702b 29525:5063dfe96a59
1 " Tests for various eval things. 1 (binary file application/octet-stream, hash: 6ef0dc969c5bd94983a2c4783d6a17b61a603b5f)
2
3 source view_util.vim
4
5 function s:foo() abort
6 try
7 return [] == 0
8 catch
9 return 1
10 endtry
11 endfunction
12
13 func Test_catch_return_with_error()
14 call assert_equal(1, s:foo())
15 endfunc
16
17 func Test_nocatch_restore_silent_emsg()
18 silent! try
19 throw 1
20 catch
21 endtry
22 echoerr 'wrong again'
23 call assert_equal('wrong again', ScreenLine(&lines))
24 endfunc
25
26 func Test_mkdir_p()
27 call mkdir('Xmkdir/nested', 'p')
28 call assert_true(isdirectory('Xmkdir/nested'))
29 try
30 " Trying to make existing directories doesn't error
31 call mkdir('Xmkdir', 'p')
32 call mkdir('Xmkdir/nested', 'p')
33 catch /E739:/
34 call assert_report('mkdir(..., "p") failed for an existing directory')
35 endtry
36 " 'p' doesn't suppress real errors
37 call writefile([], 'Xfile')
38 call assert_fails('call mkdir("Xfile", "p")', 'E739:')
39 call delete('Xfile')
40 call delete('Xmkdir', 'rf')
41 call assert_equal(0, mkdir(test_null_string()))
42 call assert_fails('call mkdir([])', 'E730:')
43 call assert_fails('call mkdir("abc", [], [])', 'E745:')
44 endfunc
45
46 func Test_line_continuation()
47 let array = [5,
48 "\ ignore this
49 \ 6,
50 "\ more to ignore
51 "\ more moreto ignore
52 \ ]
53 "\ and some more
54 call assert_equal([5, 6], array)
55 endfunc
56
57 func Test_E963()
58 " These commands used to cause an internal error prior to vim 8.1.0563
59 let v_e = v:errors
60 let v_o = v:oldfiles
61 call assert_fails("let v:errors=''", 'E963:')
62 call assert_equal(v_e, v:errors)
63 call assert_fails("let v:oldfiles=''", 'E963:')
64 call assert_equal(v_o, v:oldfiles)
65 endfunc
66
67 func Test_for_invalid()
68 call assert_fails("for x in 99", 'E1098:')
69 call assert_fails("for x in function('winnr')", 'E1098:')
70 call assert_fails("for x in {'a': 9}", 'E1098:')
71
72 if 0
73 /1/5/2/s/\n
74 endif
75 redraw
76 endfunc
77
78 func Test_readfile_binary()
79 new
80 call setline(1, ['one', 'two', 'three'])
81 setlocal ff=dos
82 silent write XReadfile_bin
83 let lines = 'XReadfile_bin'->readfile()
84 call assert_equal(['one', 'two', 'three'], lines)
85 let lines = readfile('XReadfile_bin', '', 2)
86 call assert_equal(['one', 'two'], lines)
87 let lines = readfile('XReadfile_bin', 'b')
88 call assert_equal(["one\r", "two\r", "three\r", ""], lines)
89 let lines = readfile('XReadfile_bin', 'b', 2)
90 call assert_equal(["one\r", "two\r"], lines)
91
92 bwipe!
93 call delete('XReadfile_bin')
94 endfunc
95
96 func Test_readfile_binary_empty()
97 call writefile([], 'Xempty-file')
98 " This used to compare uninitialized memory in Vim <= 8.2.4065
99 call assert_equal([''], readfile('Xempty-file', 'b'))
100 call delete('Xempty-file')
101 endfunc
102
103 func Test_readfile_bom()
104 call writefile(["\ufeffFOO", "FOO\ufeffBAR"], 'XReadfile_bom')
105 call assert_equal(['FOO', 'FOOBAR'], readfile('XReadfile_bom'))
106 call delete('XReadfile_bom')
107 endfunc
108
109 func Test_readfile_max()
110 call writefile(range(1, 4), 'XReadfile_max')
111 call assert_equal(['1', '2'], readfile('XReadfile_max', '', 2))
112 call assert_equal(['3', '4'], readfile('XReadfile_max', '', -2))
113 call delete('XReadfile_max')
114 endfunc
115
116 func Test_let_errmsg()
117 call assert_fails('let v:errmsg = []', 'E730:')
118 let v:errmsg = ''
119 call assert_fails('let v:errmsg = []', 'E730:')
120 let v:errmsg = ''
121 endfunc
122
123 func Test_string_concatenation()
124 call assert_equal('ab', 'a'.'b')
125 call assert_equal('ab', 'a' .'b')
126 call assert_equal('ab', 'a'. 'b')
127 call assert_equal('ab', 'a' . 'b')
128
129 call assert_equal('ab', 'a'..'b')
130 call assert_equal('ab', 'a' ..'b')
131 call assert_equal('ab', 'a'.. 'b')
132 call assert_equal('ab', 'a' .. 'b')
133
134 let a = 'a'
135 let b = 'b'
136 let a .= b
137 call assert_equal('ab', a)
138
139 let a = 'a'
140 let a.=b
141 call assert_equal('ab', a)
142
143 let a = 'a'
144 let a ..= b
145 call assert_equal('ab', a)
146
147 let a = 'a'
148 let a..=b
149 call assert_equal('ab', a)
150
151 if has('float')
152 let a = 'A'
153 let b = 1.234
154 call assert_equal('A1.234', a .. b)
155 endif
156 endfunc
157
158 " Test fix for issue #4507
159 func Test_skip_after_throw()
160 try
161 throw 'something'
162 let x = wincol() || &ts
163 catch /something/
164 endtry
165 endfunc
166
167 scriptversion 2
168 func Test_string_concat_scriptversion2()
169 call assert_true(has('vimscript-2'))
170 let a = 'a'
171 let b = 'b'
172
173 call assert_fails('echo a . b', 'E15:')
174 call assert_fails('let a .= b', 'E985:')
175 call assert_fails('let vers = 1.2.3', 'E488:')
176
177 if has('float')
178 let f = .5
179 call assert_equal(0.5, f)
180 endif
181 endfunc
182
183 scriptversion 1
184 func Test_string_concat_scriptversion1()
185 call assert_true(has('vimscript-1'))
186 let a = 'a'
187 let b = 'b'
188
189 echo a . b
190 let a .= b
191 let vers = 1.2.3
192 call assert_equal('123', vers)
193
194 if has('float')
195 call assert_fails('let f = .5', 'E15:')
196 endif
197 endfunc
198
199 scriptversion 3
200 func Test_vvar_scriptversion3()
201 call assert_true(has('vimscript-3'))
202 call assert_fails('echo version', 'E121:')
203 call assert_false(exists('version'))
204 let version = 1
205 call assert_equal(1, version)
206 endfunc
207
208 scriptversion 2
209 func Test_vvar_scriptversion2()
210 call assert_true(exists('version'))
211 echo version
212 call assert_fails('let version = 1', 'E46:')
213 call assert_equal(v:version, version)
214
215 call assert_equal(v:version, v:versionlong / 10000)
216 call assert_true(v:versionlong > 8011525)
217 endfunc
218
219 func Test_dict_access_scriptversion2()
220 let l:x = {'foo': 1}
221
222 call assert_false(0 && l:x.foo)
223 call assert_true(1 && l:x.foo)
224 endfunc
225
226 scriptversion 4
227 func Test_vvar_scriptversion4()
228 call assert_true(has('vimscript-4'))
229 call assert_equal(17, 017)
230 call assert_equal(15, 0o17)
231 call assert_equal(15, 0O17)
232 call assert_equal(18, 018)
233 call assert_equal(511, 0o777)
234 call assert_equal(64, 0b1'00'00'00)
235 call assert_equal(1048576, 0x10'00'00)
236 call assert_equal(32768, 0o10'00'00)
237 call assert_equal(1000000, 1'000'000)
238 call assert_equal("1234", execute("echo 1'234")->trim())
239 call assert_equal('1 234', execute("echo 1''234")->trim())
240 call assert_fails("echo 1'''234", 'E115:')
241 endfunc
242
243 scriptversion 1
244 func Test_vvar_scriptversion1()
245 call assert_equal(15, 017)
246 call assert_equal(15, 0o17)
247 call assert_equal(15, 0O17)
248 call assert_equal(18, 018)
249 call assert_equal(511, 0o777)
250 endfunc
251
252 func Test_scriptversion_fail()
253 call writefile(['scriptversion 9'], 'Xversionscript')
254 call assert_fails('source Xversionscript', 'E999:')
255 call delete('Xversionscript')
256 endfunc
257
258 func Test_execute_cmd_with_null()
259 call assert_fails('execute test_null_list()', 'E730:')
260 call assert_fails('execute test_null_dict()', 'E731:')
261 call assert_fails('execute test_null_blob()', 'E976:')
262 execute test_null_string()
263 call assert_fails('execute test_null_partial()', 'E729:')
264 call assert_fails('execute test_unknown()', 'E908:')
265 if has('job')
266 call assert_fails('execute test_null_job()', 'E908:')
267 call assert_fails('execute test_null_channel()', 'E908:')
268 endif
269 endfunc
270
271 func Test_number_max_min_size()
272 " This will fail on systems without 64 bit number support or when not
273 " configured correctly.
274 call assert_equal(64, v:numbersize)
275
276 call assert_true(v:numbermin < -9999999)
277 call assert_true(v:numbermax > 9999999)
278 endfunc
279
280 func Assert_reg(name, type, value, valuestr, expr, exprstr)
281 call assert_equal(a:type, getregtype(a:name))
282 call assert_equal(a:value, getreg(a:name))
283 call assert_equal(a:valuestr, string(getreg(a:name, 0, 1)))
284 call assert_equal(a:expr, getreg(a:name, 1))
285 call assert_equal(a:exprstr, string(getreg(a:name, 1, 1)))
286 endfunc
287
288 func Test_let_register()
289 let @" = 'abc'
290 call Assert_reg('"', 'v', "abc", "['abc']", "abc", "['abc']")
291 let @" = "abc\n"
292 call Assert_reg('"', 'V', "abc\n", "['abc']", "abc\n", "['abc']")
293 let @" = "abc\<C-m>"
294 call Assert_reg('"', 'V', "abc\r\n", "['abc\r']", "abc\r\n", "['abc\r']")
295 let @= = '"abc"'
296 call Assert_reg('=', 'v', "abc", "['abc']", '"abc"', "['\"abc\"']")
297 endfunc
298
299 func Assert_regput(name, result)
300 new
301 execute "silent normal! o==\n==\e\"" . a:name . "P"
302 call assert_equal(a:result, getline(2, line('$')))
303 bwipe!
304 endfunc
305
306 func Test_setreg_basic()
307 call setreg('a', 'abcA', 'c')
308 call Assert_reg('a', 'v', "abcA", "['abcA']", "abcA", "['abcA']")
309 call Assert_regput('a', ['==', '=abcA='])
310
311 call setreg('A', 'abcAc', 'c')
312 call Assert_reg('A', 'v', "abcAabcAc", "['abcAabcAc']", "abcAabcAc", "['abcAabcAc']")
313 call Assert_regput('a', ['==', '=abcAabcAc='])
314
315 call setreg('A', 'abcAl', 'l')
316 call Assert_reg('A', 'V', "abcAabcAcabcAl\n", "['abcAabcAcabcAl']", "abcAabcAcabcAl\n", "['abcAabcAcabcAl']")
317 call Assert_regput('a', ['==', 'abcAabcAcabcAl', '=='])
318
319 call setreg('A', 'abcAc2','c')
320 call Assert_reg('A', 'v', "abcAabcAcabcAl\nabcAc2", "['abcAabcAcabcAl', 'abcAc2']", "abcAabcAcabcAl\nabcAc2", "['abcAabcAcabcAl', 'abcAc2']")
321 call Assert_regput('a', ['==', '=abcAabcAcabcAl', 'abcAc2='])
322
323 call setreg('b', 'abcB', 'v')
324 call Assert_reg('b', 'v', "abcB", "['abcB']", "abcB", "['abcB']")
325 call Assert_regput('b', ['==', '=abcB='])
326
327 call setreg('b', 'abcBc', 'ca')
328 call Assert_reg('b', 'v', "abcBabcBc", "['abcBabcBc']", "abcBabcBc", "['abcBabcBc']")
329 call Assert_regput('b', ['==', '=abcBabcBc='])
330
331 call setreg('b', 'abcBb', 'ba')
332 call Assert_reg('b', "\<C-V>5", "abcBabcBcabcBb", "['abcBabcBcabcBb']", "abcBabcBcabcBb", "['abcBabcBcabcBb']")
333 call Assert_regput('b', ['==', '=abcBabcBcabcBb='])
334
335 call setreg('b', 'abcBc2','ca')
336 call Assert_reg('b', "v", "abcBabcBcabcBb\nabcBc2", "['abcBabcBcabcBb', 'abcBc2']", "abcBabcBcabcBb\nabcBc2", "['abcBabcBcabcBb', 'abcBc2']")
337 call Assert_regput('b', ['==', '=abcBabcBcabcBb', 'abcBc2='])
338
339 call setreg('b', 'abcBb2','b50a')
340 call Assert_reg('b', "\<C-V>50", "abcBabcBcabcBb\nabcBc2abcBb2", "['abcBabcBcabcBb', 'abcBc2abcBb2']", "abcBabcBcabcBb\nabcBc2abcBb2", "['abcBabcBcabcBb', 'abcBc2abcBb2']")
341 call Assert_regput('b', ['==', '=abcBabcBcabcBb =', ' abcBc2abcBb2'])
342
343 call setreg('c', 'abcC', 'l')
344 call Assert_reg('c', 'V', "abcC\n", "['abcC']", "abcC\n", "['abcC']")
345 call Assert_regput('c', ['==', 'abcC', '=='])
346
347 call setreg('C', 'abcCl', 'l')
348 call Assert_reg('C', 'V', "abcC\nabcCl\n", "['abcC', 'abcCl']", "abcC\nabcCl\n", "['abcC', 'abcCl']")
349 call Assert_regput('c', ['==', 'abcC', 'abcCl', '=='])
350
351 call setreg('C', 'abcCc', 'c')
352 call Assert_reg('C', 'v', "abcC\nabcCl\nabcCc", "['abcC', 'abcCl', 'abcCc']", "abcC\nabcCl\nabcCc", "['abcC', 'abcCl', 'abcCc']")
353 call Assert_regput('c', ['==', '=abcC', 'abcCl', 'abcCc='])
354
355 call setreg('d', 'abcD', 'V')
356 call Assert_reg('d', 'V', "abcD\n", "['abcD']", "abcD\n", "['abcD']")
357 call Assert_regput('d', ['==', 'abcD', '=='])
358
359 call setreg('D', 'abcDb', 'b')
360 call Assert_reg('d', "\<C-V>5", "abcD\nabcDb", "['abcD', 'abcDb']", "abcD\nabcDb", "['abcD', 'abcDb']")
361 call Assert_regput('d', ['==', '=abcD =', ' abcDb'])
362
363 call setreg('e', 'abcE', 'b')
364 call Assert_reg('e', "\<C-V>4", "abcE", "['abcE']", "abcE", "['abcE']")
365 call Assert_regput('e', ['==', '=abcE='])
366
367 call setreg('E', 'abcEb', 'b')
368 call Assert_reg('E', "\<C-V>5", "abcE\nabcEb", "['abcE', 'abcEb']", "abcE\nabcEb", "['abcE', 'abcEb']")
369 call Assert_regput('e', ['==', '=abcE =', ' abcEb'])
370
371 call setreg('E', 'abcEl', 'l')
372 call Assert_reg('E', "V", "abcE\nabcEb\nabcEl\n", "['abcE', 'abcEb', 'abcEl']", "abcE\nabcEb\nabcEl\n", "['abcE', 'abcEb', 'abcEl']")
373 call Assert_regput('e', ['==', 'abcE', 'abcEb', 'abcEl', '=='])
374
375 call setreg('f', 'abcF', "\<C-v>")
376 call Assert_reg('f', "\<C-V>4", "abcF", "['abcF']", "abcF", "['abcF']")
377 call Assert_regput('f', ['==', '=abcF='])
378
379 call setreg('F', 'abcFc', 'c')
380 call Assert_reg('F', "v", "abcF\nabcFc", "['abcF', 'abcFc']", "abcF\nabcFc", "['abcF', 'abcFc']")
381 call Assert_regput('f', ['==', '=abcF', 'abcFc='])
382
383 call setreg('g', 'abcG', 'b10')
384 call Assert_reg('g', "\<C-V>10", "abcG", "['abcG']", "abcG", "['abcG']")
385 call Assert_regput('g', ['==', '=abcG ='])
386
387 call setreg('h', 'abcH', "\<C-v>10")
388 call Assert_reg('h', "\<C-V>10", "abcH", "['abcH']", "abcH", "['abcH']")
389 call Assert_regput('h', ['==', '=abcH ='])
390
391 call setreg('I', 'abcI')
392 call Assert_reg('I', "v", "abcI", "['abcI']", "abcI", "['abcI']")
393 call Assert_regput('I', ['==', '=abcI='])
394
395 " Appending NL with setreg()
396 call setreg('a', 'abcA2', 'c')
397 call setreg('b', 'abcB2', 'v')
398 call setreg('c', 'abcC2', 'l')
399 call setreg('d', 'abcD2', 'V')
400 call setreg('e', 'abcE2', 'b')
401 call setreg('f', 'abcF2', "\<C-v>")
402 call setreg('g', 'abcG2', 'b10')
403 call setreg('h', 'abcH2', "\<C-v>10")
404 call setreg('I', 'abcI2')
405
406 call setreg('A', "\n")
407 call Assert_reg('A', 'V', "abcA2\n", "['abcA2']", "abcA2\n", "['abcA2']")
408 call Assert_regput('A', ['==', 'abcA2', '=='])
409
410 call setreg('B', "\n", 'c')
411 call Assert_reg('B', 'v', "abcB2\n", "['abcB2', '']", "abcB2\n", "['abcB2', '']")
412 call Assert_regput('B', ['==', '=abcB2', '='])
413
414 call setreg('C', "\n")
415 call Assert_reg('C', 'V', "abcC2\n\n", "['abcC2', '']", "abcC2\n\n", "['abcC2', '']")
416 call Assert_regput('C', ['==', 'abcC2', '', '=='])
417
418 call setreg('D', "\n", 'l')
419 call Assert_reg('D', 'V', "abcD2\n\n", "['abcD2', '']", "abcD2\n\n", "['abcD2', '']")
420 call Assert_regput('D', ['==', 'abcD2', '', '=='])
421
422 call setreg('E', "\n")
423 call Assert_reg('E', 'V', "abcE2\n\n", "['abcE2', '']", "abcE2\n\n", "['abcE2', '']")
424 call Assert_regput('E', ['==', 'abcE2', '', '=='])
425
426 call setreg('F', "\n", 'b')
427 call Assert_reg('F', "\<C-V>0", "abcF2\n", "['abcF2', '']", "abcF2\n", "['abcF2', '']")
428 call Assert_regput('F', ['==', '=abcF2=', ' '])
429
430 " Setting lists with setreg()
431 call setreg('a', ['abcA3'], 'c')
432 call Assert_reg('a', 'v', "abcA3", "['abcA3']", "abcA3", "['abcA3']")
433 call Assert_regput('a', ['==', '=abcA3='])
434
435 call setreg('b', ['abcB3'], 'l')
436 call Assert_reg('b', 'V', "abcB3\n", "['abcB3']", "abcB3\n", "['abcB3']")
437 call Assert_regput('b', ['==', 'abcB3', '=='])
438
439 call setreg('c', ['abcC3'], 'b')
440 call Assert_reg('c', "\<C-V>5", "abcC3", "['abcC3']", "abcC3", "['abcC3']")
441 call Assert_regput('c', ['==', '=abcC3='])
442
443 call setreg('d', ['abcD3'])
444 call Assert_reg('d', 'V', "abcD3\n", "['abcD3']", "abcD3\n", "['abcD3']")
445 call Assert_regput('d', ['==', 'abcD3', '=='])
446
447 call setreg('e', [1, 2, 'abc', 3])
448 call Assert_reg('e', 'V', "1\n2\nabc\n3\n", "['1', '2', 'abc', '3']", "1\n2\nabc\n3\n", "['1', '2', 'abc', '3']")
449 call Assert_regput('e', ['==', '1', '2', 'abc', '3', '=='])
450
451 call setreg('f', [1, 2, 3])
452 call Assert_reg('f', 'V', "1\n2\n3\n", "['1', '2', '3']", "1\n2\n3\n", "['1', '2', '3']")
453 call Assert_regput('f', ['==', '1', '2', '3', '=='])
454
455 " Appending lists with setreg()
456 call setreg('A', ['abcA3c'], 'c')
457 call Assert_reg('A', 'v', "abcA3\nabcA3c", "['abcA3', 'abcA3c']", "abcA3\nabcA3c", "['abcA3', 'abcA3c']")
458 call Assert_regput('A', ['==', '=abcA3', 'abcA3c='])
459
460 call setreg('b', ['abcB3l'], 'la')
461 call Assert_reg('b', 'V', "abcB3\nabcB3l\n", "['abcB3', 'abcB3l']", "abcB3\nabcB3l\n", "['abcB3', 'abcB3l']")
462 call Assert_regput('b', ['==', 'abcB3', 'abcB3l', '=='])
463
464 call setreg('C', ['abcC3b'], 'lb')
465 call Assert_reg('C', "\<C-V>6", "abcC3\nabcC3b", "['abcC3', 'abcC3b']", "abcC3\nabcC3b", "['abcC3', 'abcC3b']")
466 call Assert_regput('C', ['==', '=abcC3 =', ' abcC3b'])
467
468 call setreg('D', ['abcD32'])
469 call Assert_reg('D', 'V', "abcD3\nabcD32\n", "['abcD3', 'abcD32']", "abcD3\nabcD32\n", "['abcD3', 'abcD32']")
470 call Assert_regput('D', ['==', 'abcD3', 'abcD32', '=='])
471
472 call setreg('A', ['abcA32'])
473 call Assert_reg('A', 'V', "abcA3\nabcA3c\nabcA32\n", "['abcA3', 'abcA3c', 'abcA32']", "abcA3\nabcA3c\nabcA32\n", "['abcA3', 'abcA3c', 'abcA32']")
474 call Assert_regput('A', ['==', 'abcA3', 'abcA3c', 'abcA32', '=='])
475
476 call setreg('B', ['abcB3c'], 'c')
477 call Assert_reg('B', 'v', "abcB3\nabcB3l\nabcB3c", "['abcB3', 'abcB3l', 'abcB3c']", "abcB3\nabcB3l\nabcB3c", "['abcB3', 'abcB3l', 'abcB3c']")
478 call Assert_regput('B', ['==', '=abcB3', 'abcB3l', 'abcB3c='])
479
480 call setreg('C', ['abcC3l'], 'l')
481 call Assert_reg('C', 'V', "abcC3\nabcC3b\nabcC3l\n", "['abcC3', 'abcC3b', 'abcC3l']", "abcC3\nabcC3b\nabcC3l\n", "['abcC3', 'abcC3b', 'abcC3l']")
482 call Assert_regput('C', ['==', 'abcC3', 'abcC3b', 'abcC3l', '=='])
483
484 call setreg('D', ['abcD3b'], 'b')
485 call Assert_reg('D', "\<C-V>6", "abcD3\nabcD32\nabcD3b", "['abcD3', 'abcD32', 'abcD3b']", "abcD3\nabcD32\nabcD3b", "['abcD3', 'abcD32', 'abcD3b']")
486 call Assert_regput('D', ['==', '=abcD3 =', ' abcD32', ' abcD3b'])
487
488 " Appending lists with NL with setreg()
489 call setreg('A', ["\n", 'abcA3l2'], 'l')
490 call Assert_reg('A', "V", "abcA3\nabcA3c\nabcA32\n\n\nabcA3l2\n", "['abcA3', 'abcA3c', 'abcA32', '\n', 'abcA3l2']", "abcA3\nabcA3c\nabcA32\n\n\nabcA3l2\n", "['abcA3', 'abcA3c', 'abcA32', '\n', 'abcA3l2']")
491 call Assert_regput('A', ['==', 'abcA3', 'abcA3c', 'abcA32', "\n", 'abcA3l2', '=='])
492
493 call setreg('B', ["\n", 'abcB3c2'], 'c')
494 call Assert_reg('B', "v", "abcB3\nabcB3l\nabcB3c\n\n\nabcB3c2", "['abcB3', 'abcB3l', 'abcB3c', '\n', 'abcB3c2']", "abcB3\nabcB3l\nabcB3c\n\n\nabcB3c2", "['abcB3', 'abcB3l', 'abcB3c', '\n', 'abcB3c2']")
495 call Assert_regput('B', ['==', '=abcB3', 'abcB3l', 'abcB3c', "\n", 'abcB3c2='])
496
497 call setreg('C', ["\n", 'abcC3b2'], 'b')
498 call Assert_reg('C', "7", "abcC3\nabcC3b\nabcC3l\n\n\nabcC3b2", "['abcC3', 'abcC3b', 'abcC3l', '\n', 'abcC3b2']", "abcC3\nabcC3b\nabcC3l\n\n\nabcC3b2", "['abcC3', 'abcC3b', 'abcC3l', '\n', 'abcC3b2']")
499 call Assert_regput('C', ['==', '=abcC3 =', ' abcC3b', ' abcC3l', " \n", ' abcC3b2'])
500
501 call setreg('D', ["\n", 'abcD3b50'],'b50')
502 call Assert_reg('D', "50", "abcD3\nabcD32\nabcD3b\n\n\nabcD3b50", "['abcD3', 'abcD32', 'abcD3b', '\n', 'abcD3b50']", "abcD3\nabcD32\nabcD3b\n\n\nabcD3b50", "['abcD3', 'abcD32', 'abcD3b', '\n', 'abcD3b50']")
503 call Assert_regput('D', ['==', '=abcD3 =', ' abcD32', ' abcD3b', " \n", ' abcD3b50'])
504
505 " Setting lists with NLs with setreg()
506 call setreg('a', ['abcA4-0', "\n", "abcA4-2\n", "\nabcA4-3", "abcA4-4\nabcA4-4-2"])
507 call Assert_reg('a', "V", "abcA4-0\n\n\nabcA4-2\n\n\nabcA4-3\nabcA4-4\nabcA4-4-2\n", "['abcA4-0', '\n', 'abcA4-2\n', '\nabcA4-3', 'abcA4-4\nabcA4-4-2']", "abcA4-0\n\n\nabcA4-2\n\n\nabcA4-3\nabcA4-4\nabcA4-4-2\n", "['abcA4-0', '\n', 'abcA4-2\n', '\nabcA4-3', 'abcA4-4\nabcA4-4-2']")
508 call Assert_regput('a', ['==', 'abcA4-0', "\n", "abcA4-2\n", "\nabcA4-3", "abcA4-4\nabcA4-4-2", '=='])
509
510 call setreg('b', ['abcB4c-0', "\n", "abcB4c-2\n", "\nabcB4c-3", "abcB4c-4\nabcB4c-4-2"], 'c')
511 call Assert_reg('b', "v", "abcB4c-0\n\n\nabcB4c-2\n\n\nabcB4c-3\nabcB4c-4\nabcB4c-4-2", "['abcB4c-0', '\n', 'abcB4c-2\n', '\nabcB4c-3', 'abcB4c-4\nabcB4c-4-2']", "abcB4c-0\n\n\nabcB4c-2\n\n\nabcB4c-3\nabcB4c-4\nabcB4c-4-2", "['abcB4c-0', '\n', 'abcB4c-2\n', '\nabcB4c-3', 'abcB4c-4\nabcB4c-4-2']")
512 call Assert_regput('b', ['==', '=abcB4c-0', "\n", "abcB4c-2\n", "\nabcB4c-3", "abcB4c-4\nabcB4c-4-2="])
513
514 call setreg('c', ['abcC4l-0', "\n", "abcC4l-2\n", "\nabcC4l-3", "abcC4l-4\nabcC4l-4-2"], 'l')
515 call Assert_reg('c', "V", "abcC4l-0\n\n\nabcC4l-2\n\n\nabcC4l-3\nabcC4l-4\nabcC4l-4-2\n", "['abcC4l-0', '\n', 'abcC4l-2\n', '\nabcC4l-3', 'abcC4l-4\nabcC4l-4-2']", "abcC4l-0\n\n\nabcC4l-2\n\n\nabcC4l-3\nabcC4l-4\nabcC4l-4-2\n", "['abcC4l-0', '\n', 'abcC4l-2\n', '\nabcC4l-3', 'abcC4l-4\nabcC4l-4-2']")
516 call Assert_regput('c', ['==', 'abcC4l-0', "\n", "abcC4l-2\n", "\nabcC4l-3", "abcC4l-4\nabcC4l-4-2", '=='])
517
518 call setreg('d', ['abcD4b-0', "\n", "abcD4b-2\n", "\nabcD4b-3", "abcD4b-4\nabcD4b-4-2"], 'b')
519 call Assert_reg('d', "19", "abcD4b-0\n\n\nabcD4b-2\n\n\nabcD4b-3\nabcD4b-4\nabcD4b-4-2", "['abcD4b-0', '\n', 'abcD4b-2\n', '\nabcD4b-3', 'abcD4b-4\nabcD4b-4-2']", "abcD4b-0\n\n\nabcD4b-2\n\n\nabcD4b-3\nabcD4b-4\nabcD4b-4-2", "['abcD4b-0', '\n', 'abcD4b-2\n', '\nabcD4b-3', 'abcD4b-4\nabcD4b-4-2']")
520 call Assert_regput('d', ['==', '=abcD4b-0 =', " \n", " abcD4b-2\n", " \nabcD4b-3", " abcD4b-4\nabcD4b-4-2"])
521
522 call setreg('e', ['abcE4b10-0', "\n", "abcE4b10-2\n", "\nabcE4b10-3", "abcE4b10-4\nabcE4b10-4-2"], 'b10')
523 call Assert_reg('e', "10", "abcE4b10-0\n\n\nabcE4b10-2\n\n\nabcE4b10-3\nabcE4b10-4\nabcE4b10-4-2", "['abcE4b10-0', '\n', 'abcE4b10-2\n', '\nabcE4b10-3', 'abcE4b10-4\nabcE4b10-4-2']", "abcE4b10-0\n\n\nabcE4b10-2\n\n\nabcE4b10-3\nabcE4b10-4\nabcE4b10-4-2", "['abcE4b10-0', '\n', 'abcE4b10-2\n', '\nabcE4b10-3', 'abcE4b10-4\nabcE4b10-4-2']")
524 call Assert_regput('e', ['==', '=abcE4b10-0=', " \n", " abcE4b10-2\n", " \nabcE4b10-3", " abcE4b10-4\nabcE4b10-4-2"])
525
526 " Search and expressions
527 call setreg('/', ['abc/'])
528 call Assert_reg('/', 'v', "abc/", "['abc/']", "abc/", "['abc/']")
529 call Assert_regput('/', ['==', '=abc/='])
530
531 call setreg('/', ["abc/\n"])
532 call Assert_reg('/', 'v', "abc/\n", "['abc/\n']", "abc/\n", "['abc/\n']")
533 call Assert_regput('/', ['==', "=abc/\n="])
534
535 call setreg('=', ['"abc/"'])
536 call Assert_reg('=', 'v', "abc/", "['abc/']", '"abc/"', "['\"abc/\"']")
537
538 call setreg('=', ["\"abc/\n\""])
539 call Assert_reg('=', 'v', "abc/\n", "['abc/\n']", "\"abc/\n\"", "['\"abc/\n\"']")
540
541 " System clipboard
542 if has('clipboard')
543 new | only!
544 call setline(1, ['clipboard contents', 'something else'])
545 " Save and restore system clipboard.
546 " If no connection to X-Server is possible, test should succeed.
547 let _clipreg = ['*', getreg('*'), getregtype('*')]
548 let _clipopt = &cb
549 let &cb='unnamed'
550 1y
551 call Assert_reg('*', 'V', "clipboard contents\n", "['clipboard contents']", "clipboard contents\n", "['clipboard contents']")
552 tabdo :windo :echo "hi"
553 2y
554 call Assert_reg('*', 'V', "something else\n", "['something else']", "something else\n", "['something else']")
555 let &cb=_clipopt
556 call call('setreg', _clipreg)
557 enew!
558 endif
559
560 " Error cases
561 call assert_fails('call setreg()', 'E119:')
562 call assert_fails('call setreg(1)', 'E119:')
563 call assert_fails('call setreg(1, 2, 3, 4)', 'E118:')
564 call assert_fails('call setreg([], 2)', 'E730:')
565 call assert_fails('call setreg(1, 2, [])', 'E730:')
566 call assert_fails('call setreg("/", ["1", "2"])', 'E883:')
567 call assert_fails('call setreg("=", ["1", "2"])', 'E883:')
568 call assert_fails('call setreg(1, ["", "", [], ""])', 'E730:')
569 endfunc
570
571 func Test_curly_assignment()
572 let s:svar = 'svar'
573 let g:gvar = 'gvar'
574 let lname = 'gvar'
575 let gname = 'gvar'
576 let {'s:'.lname} = {'g:'.gname}
577 call assert_equal('gvar', s:gvar)
578 let s:gvar = ''
579 let { 's:'.lname } = { 'g:'.gname }
580 call assert_equal('gvar', s:gvar)
581 let s:gvar = ''
582 let { 's:' . lname } = { 'g:' . gname }
583 call assert_equal('gvar', s:gvar)
584 let s:gvar = ''
585 let { 's:' .. lname } = { 'g:' .. gname }
586 call assert_equal('gvar', s:gvar)
587
588 unlet s:svar
589 unlet s:gvar
590 unlet g:gvar
591 endfunc
592
593 func Test_deep_recursion()
594 " this was running out of stack
595 call assert_fails("exe 'if ' .. repeat('(', 1002)", 'E1169: Expression too recursive: ((')
596 endfunc
597
598 " K_SPECIAL in the modified character used be escaped, which causes
599 " double-escaping with feedkeys() or as the return value of an <expr> mapping,
600 " and doesn't match what getchar() returns,
601 func Test_modified_char_no_escape_special()
602 nnoremap <M-…> <Cmd>let g:got_m_ellipsis += 1<CR>
603 call feedkeys("\<M-…>", 't')
604 call assert_equal("\<M-…>", getchar())
605 let g:got_m_ellipsis = 0
606 call feedkeys("\<M-…>", 'xt')
607 call assert_equal(1, g:got_m_ellipsis)
608 func Func()
609 return "\<M-…>"
610 endfunc
611 nmap <expr> <F2> Func()
612 call feedkeys("\<F2>", 'xt')
613 call assert_equal(2, g:got_m_ellipsis)
614 delfunc Func
615 nunmap <F2>
616 unlet g:got_m_ellipsis
617 nunmap <M-…>
618 endfunc
619
620 " vim: shiftwidth=2 sts=2 expandtab