1" Tests for various eval things.
2
3function s:foo() abort
4  try
5    return [] == 0
6  catch
7    return 1
8  endtry
9endfunction
10
11func Test_catch_return_with_error()
12  call assert_equal(1, s:foo())
13endfunc
14
15func Test_nocatch_restore_silent_emsg()
16  silent! try
17    throw 1
18  catch
19  endtry
20  echoerr 'wrong'
21  let c1 = nr2char(screenchar(&lines, 1))
22  let c2 = nr2char(screenchar(&lines, 2))
23  let c3 = nr2char(screenchar(&lines, 3))
24  let c4 = nr2char(screenchar(&lines, 4))
25  let c5 = nr2char(screenchar(&lines, 5))
26  call assert_equal('wrong', c1 . c2 . c3 . c4 . c5)
27endfunc
28
29func Test_mkdir_p()
30  call mkdir('Xmkdir/nested', 'p')
31  call assert_true(isdirectory('Xmkdir/nested'))
32  try
33    " Trying to make existing directories doesn't error
34    call mkdir('Xmkdir', 'p')
35    call mkdir('Xmkdir/nested', 'p')
36  catch /E739:/
37    call assert_report('mkdir(..., "p") failed for an existing directory')
38  endtry
39  " 'p' doesn't suppress real errors
40  call writefile([], 'Xfile')
41  call assert_fails('call mkdir("Xfile", "p")', 'E739')
42  call delete('Xfile')
43  call delete('Xmkdir', 'rf')
44  call assert_equal(0, mkdir(test_null_string()))
45  call assert_fails('call mkdir([])', 'E730')
46  call assert_fails('call mkdir("abc", [], [])', 'E745')
47endfunc
48
49func Test_line_continuation()
50  let array = [5,
51	"\ ignore this
52	\ 6,
53	"\ more to ignore
54	"\ more moreto ignore
55	\ ]
56	"\ and some more
57  call assert_equal([5, 6], array)
58endfunc
59
60func Test_E963()
61  " These commands used to cause an internal error prior to vim 8.1.0563
62  let v_e = v:errors
63  let v_o = v:oldfiles
64  call assert_fails("let v:errors=''", 'E963:')
65  call assert_equal(v_e, v:errors)
66  call assert_fails("let v:oldfiles=''", 'E963:')
67  call assert_equal(v_o, v:oldfiles)
68endfunc
69
70func Test_for_invalid()
71  call assert_fails("for x in 99", 'E714:')
72  call assert_fails("for x in 'asdf'", 'E714:')
73  call assert_fails("for x in {'a': 9}", 'E714:')
74endfunc
75
76func Test_readfile_binary()
77  new
78  call setline(1, ['one', 'two', 'three'])
79  setlocal ff=dos
80  silent write XReadfile
81  let lines = 'XReadfile'->readfile()
82  call assert_equal(['one', 'two', 'three'], lines)
83  let lines = readfile('XReadfile', '', 2)
84  call assert_equal(['one', 'two'], lines)
85  let lines = readfile('XReadfile', 'b')
86  call assert_equal(["one\r", "two\r", "three\r", ""], lines)
87  let lines = readfile('XReadfile', 'b', 2)
88  call assert_equal(["one\r", "two\r"], lines)
89
90  bwipe!
91  call delete('XReadfile')
92endfunc
93
94func Test_let_errmsg()
95  call assert_fails('let v:errmsg = []', 'E730:')
96  let v:errmsg = ''
97  call assert_fails('let v:errmsg = []', 'E730:')
98  let v:errmsg = ''
99endfunc
100
101func Test_string_concatenation()
102  call assert_equal('ab', 'a'.'b')
103  call assert_equal('ab', 'a' .'b')
104  call assert_equal('ab', 'a'. 'b')
105  call assert_equal('ab', 'a' . 'b')
106
107  call assert_equal('ab', 'a'..'b')
108  call assert_equal('ab', 'a' ..'b')
109  call assert_equal('ab', 'a'.. 'b')
110  call assert_equal('ab', 'a' .. 'b')
111
112  let a = 'a'
113  let b = 'b'
114  let a .= b
115  call assert_equal('ab', a)
116
117  let a = 'a'
118  let a.=b
119  call assert_equal('ab', a)
120
121  let a = 'a'
122  let a ..= b
123  call assert_equal('ab', a)
124
125  let a = 'a'
126  let a..=b
127  call assert_equal('ab', a)
128endfunc
129
130" Test fix for issue #4507
131func Test_skip_after_throw()
132  try
133    throw 'something'
134    let x = wincol() || &ts
135  catch /something/
136  endtry
137endfunc
138
139scriptversion 2
140func Test_string_concat_scriptversion2()
141  call assert_true(has('vimscript-2'))
142  let a = 'a'
143  let b = 'b'
144
145  call assert_fails('echo a . b', 'E15:')
146  call assert_fails('let a .= b', 'E985:')
147  call assert_fails('let vers = 1.2.3', 'E15:')
148
149  if has('float')
150    let f = .5
151    call assert_equal(0.5, f)
152  endif
153endfunc
154
155scriptversion 1
156func Test_string_concat_scriptversion1()
157  call assert_true(has('vimscript-1'))
158  let a = 'a'
159  let b = 'b'
160
161  echo a . b
162  let a .= b
163  let vers = 1.2.3
164  call assert_equal('123', vers)
165
166  if has('float')
167    call assert_fails('let f = .5', 'E15:')
168  endif
169endfunc
170
171scriptversion 3
172func Test_vvar_scriptversion3()
173  call assert_true(has('vimscript-3'))
174  call assert_fails('echo version', 'E121:')
175  call assert_false(exists('version'))
176  let version = 1
177  call assert_equal(1, version)
178endfunc
179
180scriptversion 2
181func Test_vvar_scriptversion2()
182  call assert_true(exists('version'))
183  echo version
184  call assert_fails('let version = 1', 'E46:')
185  call assert_equal(v:version, version)
186
187  call assert_equal(v:version, v:versionlong / 10000)
188  call assert_true(v:versionlong > 8011525)
189endfunc
190
191func Test_dict_access_scriptversion2()
192  let l:x = {'foo': 1}
193
194  call assert_false(0 && l:x.foo)
195  call assert_true(1 && l:x.foo)
196endfunc
197
198scriptversion 4
199func Test_vvar_scriptversion4()
200  call assert_true(has('vimscript-4'))
201  call assert_equal(17, 017)
202  call assert_equal(15, 0o17)
203  call assert_equal(15, 0O17)
204  call assert_equal(18, 018)
205  call assert_equal(64, 0b1'00'00'00)
206  call assert_equal(1048576, 0x10'00'00)
207  call assert_equal(32768, 0o10'00'00)
208  call assert_equal(1000000, 1'000'000)
209  call assert_equal("1234", execute("echo 1'234")->trim())
210  call assert_equal('1  234', execute("echo 1''234")->trim())
211  call assert_fails("echo 1'''234", 'E115:')
212endfunc
213
214scriptversion 1
215func Test_vvar_scriptversion1()
216  call assert_equal(15, 017)
217  call assert_equal(15, 0o17)
218  call assert_equal(15, 0O17)
219  call assert_equal(18, 018)
220endfunc
221
222func Test_scriptversion_fail()
223  call writefile(['scriptversion 9'], 'Xversionscript')
224  call assert_fails('source Xversionscript', 'E999:')
225  call delete('Xversionscript')
226endfunc
227
228func Test_execute_cmd_with_null()
229  call assert_fails('execute test_null_list()', 'E730:')
230  call assert_fails('execute test_null_dict()', 'E731:')
231  call assert_fails('execute test_null_blob()', 'E976:')
232  execute test_null_string()
233  call assert_fails('execute test_null_partial()', 'E729:')
234  call assert_fails('execute test_unknown()', 'E908:')
235  if has('job')
236    call assert_fails('execute test_null_job()', 'E908:')
237    call assert_fails('execute test_null_channel()', 'E908:')
238  endif
239endfunc
240
241func Test_numbersize()
242  " This will fail on systems without 64 bit int support or when not configured
243  " correctly.
244  call assert_equal(64, v:numbersize)
245endfunc
246
247func Assert_reg(name, type, value, valuestr, expr, exprstr)
248  call assert_equal(a:type, getregtype(a:name))
249  call assert_equal(a:value, getreg(a:name))
250  call assert_equal(a:valuestr, string(getreg(a:name, 0, 1)))
251  call assert_equal(a:expr, getreg(a:name, 1))
252  call assert_equal(a:exprstr, string(getreg(a:name, 1, 1)))
253endfunc
254
255func Test_let_register()
256  let @" = 'abc'
257  call Assert_reg('"', 'v', "abc", "['abc']", "abc", "['abc']")
258  let @" = "abc\n"
259  call Assert_reg('"', 'V', "abc\n", "['abc']", "abc\n", "['abc']")
260  let @" = "abc\<C-m>"
261  call Assert_reg('"', 'V', "abc\r\n", "['abc\r']", "abc\r\n", "['abc\r']")
262  let @= = '"abc"'
263  call Assert_reg('=', 'v', "abc", "['abc']", '"abc"', "['\"abc\"']")
264endfunc
265
266func Assert_regput(name, result)
267  new
268  execute "silent normal! o==\n==\e\"" . a:name . "P"
269  call assert_equal(a:result, getline(2, line('$')))
270  bwipe!
271endfunc
272
273func Test_setreg_basic()
274  call setreg('a', 'abcA', 'c')
275  call Assert_reg('a', 'v', "abcA", "['abcA']", "abcA", "['abcA']")
276  call Assert_regput('a', ['==', '=abcA='])
277
278  call setreg('A', 'abcAc', 'c')
279  call Assert_reg('A', 'v', "abcAabcAc", "['abcAabcAc']", "abcAabcAc", "['abcAabcAc']")
280  call Assert_regput('a', ['==', '=abcAabcAc='])
281
282  call setreg('A', 'abcAl', 'l')
283  call Assert_reg('A', 'V', "abcAabcAcabcAl\n", "['abcAabcAcabcAl']", "abcAabcAcabcAl\n", "['abcAabcAcabcAl']")
284  call Assert_regput('a', ['==', 'abcAabcAcabcAl', '=='])
285
286  call setreg('A', 'abcAc2','c')
287  call Assert_reg('A', 'v', "abcAabcAcabcAl\nabcAc2", "['abcAabcAcabcAl', 'abcAc2']", "abcAabcAcabcAl\nabcAc2", "['abcAabcAcabcAl', 'abcAc2']")
288  call Assert_regput('a', ['==', '=abcAabcAcabcAl', 'abcAc2='])
289
290  call setreg('b', 'abcB', 'v')
291  call Assert_reg('b', 'v', "abcB", "['abcB']", "abcB", "['abcB']")
292  call Assert_regput('b', ['==', '=abcB='])
293
294  call setreg('b', 'abcBc', 'ca')
295  call Assert_reg('b', 'v', "abcBabcBc", "['abcBabcBc']", "abcBabcBc", "['abcBabcBc']")
296  call Assert_regput('b', ['==', '=abcBabcBc='])
297
298  call setreg('b', 'abcBb', 'ba')
299  call Assert_reg('b', "\<C-V>5", "abcBabcBcabcBb", "['abcBabcBcabcBb']", "abcBabcBcabcBb", "['abcBabcBcabcBb']")
300  call Assert_regput('b', ['==', '=abcBabcBcabcBb='])
301
302  call setreg('b', 'abcBc2','ca')
303  call Assert_reg('b', "v", "abcBabcBcabcBb\nabcBc2", "['abcBabcBcabcBb', 'abcBc2']", "abcBabcBcabcBb\nabcBc2", "['abcBabcBcabcBb', 'abcBc2']")
304  call Assert_regput('b', ['==', '=abcBabcBcabcBb', 'abcBc2='])
305
306  call setreg('b', 'abcBb2','b50a')
307  call Assert_reg('b', "\<C-V>50", "abcBabcBcabcBb\nabcBc2abcBb2", "['abcBabcBcabcBb', 'abcBc2abcBb2']", "abcBabcBcabcBb\nabcBc2abcBb2", "['abcBabcBcabcBb', 'abcBc2abcBb2']")
308  call Assert_regput('b', ['==', '=abcBabcBcabcBb                                    =', ' abcBc2abcBb2'])
309
310  call setreg('c', 'abcC', 'l')
311  call Assert_reg('c', 'V', "abcC\n", "['abcC']", "abcC\n", "['abcC']")
312  call Assert_regput('c', ['==', 'abcC', '=='])
313
314  call setreg('C', 'abcCl', 'l')
315  call Assert_reg('C', 'V', "abcC\nabcCl\n", "['abcC', 'abcCl']", "abcC\nabcCl\n", "['abcC', 'abcCl']")
316  call Assert_regput('c', ['==', 'abcC', 'abcCl', '=='])
317
318  call setreg('C', 'abcCc', 'c')
319  call Assert_reg('C', 'v', "abcC\nabcCl\nabcCc", "['abcC', 'abcCl', 'abcCc']", "abcC\nabcCl\nabcCc", "['abcC', 'abcCl', 'abcCc']")
320  call Assert_regput('c', ['==', '=abcC', 'abcCl', 'abcCc='])
321
322  call setreg('d', 'abcD', 'V')
323  call Assert_reg('d', 'V', "abcD\n", "['abcD']", "abcD\n", "['abcD']")
324  call Assert_regput('d', ['==', 'abcD', '=='])
325
326  call setreg('D', 'abcDb', 'b')
327  call Assert_reg('d', "\<C-V>5", "abcD\nabcDb", "['abcD', 'abcDb']", "abcD\nabcDb", "['abcD', 'abcDb']")
328  call Assert_regput('d', ['==', '=abcD =', ' abcDb'])
329
330  call setreg('e', 'abcE', 'b')
331  call Assert_reg('e', "\<C-V>4", "abcE", "['abcE']", "abcE", "['abcE']")
332  call Assert_regput('e', ['==', '=abcE='])
333
334  call setreg('E', 'abcEb', 'b')
335  call Assert_reg('E', "\<C-V>5", "abcE\nabcEb", "['abcE', 'abcEb']", "abcE\nabcEb", "['abcE', 'abcEb']")
336  call Assert_regput('e', ['==', '=abcE =', ' abcEb'])
337
338  call setreg('E', 'abcEl', 'l')
339  call Assert_reg('E', "V", "abcE\nabcEb\nabcEl\n", "['abcE', 'abcEb', 'abcEl']", "abcE\nabcEb\nabcEl\n", "['abcE', 'abcEb', 'abcEl']")
340  call Assert_regput('e', ['==', 'abcE', 'abcEb', 'abcEl', '=='])
341
342  call setreg('f', 'abcF', "\<C-v>")
343  call Assert_reg('f', "\<C-V>4", "abcF", "['abcF']", "abcF", "['abcF']")
344  call Assert_regput('f', ['==', '=abcF='])
345
346  call setreg('F', 'abcFc', 'c')
347  call Assert_reg('F', "v", "abcF\nabcFc", "['abcF', 'abcFc']", "abcF\nabcFc", "['abcF', 'abcFc']")
348  call Assert_regput('f', ['==', '=abcF', 'abcFc='])
349
350  call setreg('g', 'abcG', 'b10')
351  call Assert_reg('g', "\<C-V>10", "abcG", "['abcG']", "abcG", "['abcG']")
352  call Assert_regput('g', ['==', '=abcG      ='])
353
354  call setreg('h', 'abcH', "\<C-v>10")
355  call Assert_reg('h', "\<C-V>10", "abcH", "['abcH']", "abcH", "['abcH']")
356  call Assert_regput('h', ['==', '=abcH      ='])
357
358  call setreg('I', 'abcI')
359  call Assert_reg('I', "v", "abcI", "['abcI']", "abcI", "['abcI']")
360  call Assert_regput('I', ['==', '=abcI='])
361
362  " Appending NL with setreg()
363  call setreg('a', 'abcA2', 'c')
364  call setreg('b', 'abcB2', 'v')
365  call setreg('c', 'abcC2', 'l')
366  call setreg('d', 'abcD2', 'V')
367  call setreg('e', 'abcE2', 'b')
368  call setreg('f', 'abcF2', "\<C-v>")
369  call setreg('g', 'abcG2', 'b10')
370  call setreg('h', 'abcH2', "\<C-v>10")
371  call setreg('I', 'abcI2')
372
373  call setreg('A', "\n")
374  call Assert_reg('A', 'V', "abcA2\n", "['abcA2']", "abcA2\n", "['abcA2']")
375  call Assert_regput('A', ['==', 'abcA2', '=='])
376
377  call setreg('B', "\n", 'c')
378  call Assert_reg('B', 'v', "abcB2\n", "['abcB2', '']", "abcB2\n", "['abcB2', '']")
379  call Assert_regput('B', ['==', '=abcB2', '='])
380
381  call setreg('C', "\n")
382  call Assert_reg('C', 'V', "abcC2\n\n", "['abcC2', '']", "abcC2\n\n", "['abcC2', '']")
383  call Assert_regput('C', ['==', 'abcC2', '', '=='])
384
385  call setreg('D', "\n", 'l')
386  call Assert_reg('D', 'V', "abcD2\n\n", "['abcD2', '']", "abcD2\n\n", "['abcD2', '']")
387  call Assert_regput('D', ['==', 'abcD2', '', '=='])
388
389  call setreg('E', "\n")
390  call Assert_reg('E', 'V', "abcE2\n\n", "['abcE2', '']", "abcE2\n\n", "['abcE2', '']")
391  call Assert_regput('E', ['==', 'abcE2', '', '=='])
392
393  call setreg('F', "\n", 'b')
394  call Assert_reg('F', "\<C-V>0", "abcF2\n", "['abcF2', '']", "abcF2\n", "['abcF2', '']")
395  call Assert_regput('F', ['==', '=abcF2=', ' '])
396
397  " Setting lists with setreg()
398  call setreg('a', ['abcA3'], 'c')
399  call Assert_reg('a', 'v', "abcA3", "['abcA3']", "abcA3", "['abcA3']")
400  call Assert_regput('a', ['==', '=abcA3='])
401
402  call setreg('b', ['abcB3'], 'l')
403  call Assert_reg('b', 'V', "abcB3\n", "['abcB3']", "abcB3\n", "['abcB3']")
404  call Assert_regput('b', ['==', 'abcB3', '=='])
405
406  call setreg('c', ['abcC3'], 'b')
407  call Assert_reg('c', "\<C-V>5", "abcC3", "['abcC3']", "abcC3", "['abcC3']")
408  call Assert_regput('c', ['==', '=abcC3='])
409
410  call setreg('d', ['abcD3'])
411  call Assert_reg('d', 'V', "abcD3\n", "['abcD3']", "abcD3\n", "['abcD3']")
412  call Assert_regput('d', ['==', 'abcD3', '=='])
413
414  call setreg('e', [1, 2, 'abc', 3])
415  call Assert_reg('e', 'V', "1\n2\nabc\n3\n", "['1', '2', 'abc', '3']", "1\n2\nabc\n3\n", "['1', '2', 'abc', '3']")
416  call Assert_regput('e', ['==', '1', '2', 'abc', '3', '=='])
417
418  call setreg('f', [1, 2, 3])
419  call Assert_reg('f', 'V', "1\n2\n3\n", "['1', '2', '3']", "1\n2\n3\n", "['1', '2', '3']")
420  call Assert_regput('f', ['==', '1', '2', '3', '=='])
421
422  " Appending lists with setreg()
423  call setreg('A', ['abcA3c'], 'c')
424  call Assert_reg('A', 'v', "abcA3\nabcA3c", "['abcA3', 'abcA3c']", "abcA3\nabcA3c", "['abcA3', 'abcA3c']")
425  call Assert_regput('A', ['==', '=abcA3', 'abcA3c='])
426
427  call setreg('b', ['abcB3l'], 'la')
428  call Assert_reg('b', 'V', "abcB3\nabcB3l\n", "['abcB3', 'abcB3l']", "abcB3\nabcB3l\n", "['abcB3', 'abcB3l']")
429  call Assert_regput('b', ['==', 'abcB3', 'abcB3l', '=='])
430
431  call setreg('C', ['abcC3b'], 'lb')
432  call Assert_reg('C', "\<C-V>6", "abcC3\nabcC3b", "['abcC3', 'abcC3b']", "abcC3\nabcC3b", "['abcC3', 'abcC3b']")
433  call Assert_regput('C', ['==', '=abcC3 =', ' abcC3b'])
434
435  call setreg('D', ['abcD32'])
436  call Assert_reg('D', 'V', "abcD3\nabcD32\n", "['abcD3', 'abcD32']", "abcD3\nabcD32\n", "['abcD3', 'abcD32']")
437  call Assert_regput('D', ['==', 'abcD3', 'abcD32', '=='])
438
439  call setreg('A', ['abcA32'])
440  call Assert_reg('A', 'V', "abcA3\nabcA3c\nabcA32\n", "['abcA3', 'abcA3c', 'abcA32']", "abcA3\nabcA3c\nabcA32\n", "['abcA3', 'abcA3c', 'abcA32']")
441  call Assert_regput('A', ['==', 'abcA3', 'abcA3c', 'abcA32', '=='])
442
443  call setreg('B', ['abcB3c'], 'c')
444  call Assert_reg('B', 'v', "abcB3\nabcB3l\nabcB3c", "['abcB3', 'abcB3l', 'abcB3c']", "abcB3\nabcB3l\nabcB3c", "['abcB3', 'abcB3l', 'abcB3c']")
445  call Assert_regput('B', ['==', '=abcB3', 'abcB3l', 'abcB3c='])
446
447  call setreg('C', ['abcC3l'], 'l')
448  call Assert_reg('C', 'V', "abcC3\nabcC3b\nabcC3l\n", "['abcC3', 'abcC3b', 'abcC3l']", "abcC3\nabcC3b\nabcC3l\n", "['abcC3', 'abcC3b', 'abcC3l']")
449  call Assert_regput('C', ['==', 'abcC3', 'abcC3b', 'abcC3l', '=='])
450
451  call setreg('D', ['abcD3b'], 'b')
452  call Assert_reg('D', "\<C-V>6", "abcD3\nabcD32\nabcD3b", "['abcD3', 'abcD32', 'abcD3b']", "abcD3\nabcD32\nabcD3b", "['abcD3', 'abcD32', 'abcD3b']")
453  call Assert_regput('D', ['==', '=abcD3 =', ' abcD32', ' abcD3b'])
454
455  " Appending lists with NL with setreg()
456  call setreg('A', ["\n", 'abcA3l2'], 'l')
457  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']")
458  call Assert_regput('A', ['==', 'abcA3', 'abcA3c', 'abcA32', "\n", 'abcA3l2', '=='])
459
460  call setreg('B', ["\n", 'abcB3c2'], 'c')
461  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']")
462  call Assert_regput('B', ['==', '=abcB3', 'abcB3l', 'abcB3c', "\n", 'abcB3c2='])
463
464  call setreg('C', ["\n", 'abcC3b2'], 'b')
465  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']")
466  call Assert_regput('C', ['==', '=abcC3  =', ' abcC3b', ' abcC3l', " \n", ' abcC3b2'])
467
468  call setreg('D', ["\n", 'abcD3b50'],'b50')
469  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']")
470  call Assert_regput('D', ['==', '=abcD3                                             =', ' abcD32', ' abcD3b', " \n", ' abcD3b50'])
471
472  " Setting lists with NLs with setreg()
473  call setreg('a', ['abcA4-0', "\n", "abcA4-2\n", "\nabcA4-3", "abcA4-4\nabcA4-4-2"])
474  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']")
475  call Assert_regput('a', ['==', 'abcA4-0', "\n", "abcA4-2\n", "\nabcA4-3", "abcA4-4\nabcA4-4-2", '=='])
476
477  call setreg('b', ['abcB4c-0', "\n", "abcB4c-2\n", "\nabcB4c-3", "abcB4c-4\nabcB4c-4-2"], 'c')
478  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']")
479  call Assert_regput('b', ['==', '=abcB4c-0', "\n", "abcB4c-2\n", "\nabcB4c-3", "abcB4c-4\nabcB4c-4-2="])
480
481  call setreg('c', ['abcC4l-0', "\n", "abcC4l-2\n", "\nabcC4l-3", "abcC4l-4\nabcC4l-4-2"], 'l')
482  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']")
483  call Assert_regput('c', ['==', 'abcC4l-0', "\n", "abcC4l-2\n", "\nabcC4l-3", "abcC4l-4\nabcC4l-4-2", '=='])
484
485  call setreg('d', ['abcD4b-0', "\n", "abcD4b-2\n", "\nabcD4b-3", "abcD4b-4\nabcD4b-4-2"], 'b')
486  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']")
487  call Assert_regput('d', ['==', '=abcD4b-0           =', " \n", " abcD4b-2\n", " \nabcD4b-3", " abcD4b-4\nabcD4b-4-2"])
488
489  call setreg('e', ['abcE4b10-0', "\n", "abcE4b10-2\n", "\nabcE4b10-3", "abcE4b10-4\nabcE4b10-4-2"], 'b10')
490  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']")
491  call Assert_regput('e', ['==', '=abcE4b10-0=', " \n", " abcE4b10-2\n", " \nabcE4b10-3", " abcE4b10-4\nabcE4b10-4-2"])
492
493  " Search and expressions
494  call setreg('/', ['abc/'])
495  call Assert_reg('/', 'v', "abc/", "['abc/']", "abc/", "['abc/']")
496  call Assert_regput('/', ['==', '=abc/='])
497
498  call setreg('/', ["abc/\n"])
499  call Assert_reg('/', 'v', "abc/\n", "['abc/\n']", "abc/\n", "['abc/\n']")
500  call Assert_regput('/', ['==', "=abc/\n="])
501
502  call setreg('=', ['"abc/"'])
503  call Assert_reg('=', 'v', "abc/", "['abc/']", '"abc/"', "['\"abc/\"']")
504
505  call setreg('=', ["\"abc/\n\""])
506  call Assert_reg('=', 'v', "abc/\n", "['abc/\n']", "\"abc/\n\"", "['\"abc/\n\"']")
507
508  " System clipboard
509  if has('clipboard')
510    new | only!
511    call setline(1, ['clipboard contents', 'something else'])
512    " Save and restore system clipboard.
513    " If no connection to X-Server is possible, test should succeed.
514    let _clipreg = ['*', getreg('*'), getregtype('*')]
515    let _clipopt = &cb
516    let &cb='unnamed'
517    1y
518    call Assert_reg('*', 'V', "clipboard contents\n", "['clipboard contents']", "clipboard contents\n", "['clipboard contents']")
519    tabdo :windo :echo "hi"
520    2y
521    call Assert_reg('*', 'V', "something else\n", "['something else']", "something else\n", "['something else']")
522    let &cb=_clipopt
523    call call('setreg', _clipreg)
524    enew!
525  endif
526
527  " Error cases
528  call assert_fails('call setreg()', 'E119:')
529  call assert_fails('call setreg(1)', 'E119:')
530  call assert_fails('call setreg(1, 2, 3, 4)', 'E118:')
531  call assert_fails('call setreg([], 2)', 'E730:')
532  call assert_fails('call setreg(1, 2, [])', 'E730:')
533  call assert_fails('call setreg("/", ["1", "2"])', 'E883:')
534  call assert_fails('call setreg("=", ["1", "2"])', 'E883:')
535  call assert_fails('call setreg(1, ["", "", [], ""])', 'E730:')
536endfunc
537
538" vim: shiftwidth=2 sts=2 expandtab
539