blob: e32c4f5ffbdc945a52f0beec066dfd8bba41d2fb [file] [log] [blame]
Bram Moolenaar08243d22017-01-10 16:12:29 +01001" Tests for various functions.
Bram Moolenaar6d91bcb2020-08-12 18:50:36 +02002
Bram Moolenaarf1c118b2018-09-03 22:08:10 +02003source shared.vim
Bram Moolenaar8c5a2782019-08-07 23:07:07 +02004source check.vim
Bram Moolenaarc2585492019-09-22 21:29:53 +02005source term_util.vim
Bram Moolenaar4132eb52020-02-14 16:53:00 +01006source screendump.vim
Bram Moolenaar62aec932022-01-29 21:45:34 +00007import './vim9.vim' as v9
Bram Moolenaar08243d22017-01-10 16:12:29 +01008
Bram Moolenaarc7d16dc2017-11-18 20:32:03 +01009" Must be done first, since the alternate buffer must be unset.
10func Test_00_bufexists()
11 call assert_equal(0, bufexists('does_not_exist'))
12 call assert_equal(1, bufexists(bufnr('%')))
13 call assert_equal(0, bufexists(0))
14 new Xfoo
15 let bn = bufnr('%')
16 call assert_equal(1, bufexists(bn))
17 call assert_equal(1, bufexists('Xfoo'))
18 call assert_equal(1, bufexists(getcwd() . '/Xfoo'))
19 call assert_equal(1, bufexists(0))
20 bw
21 call assert_equal(0, bufexists(bn))
22 call assert_equal(0, bufexists('Xfoo'))
23endfunc
24
Bram Moolenaar79296512020-03-22 16:17:14 +010025func Test_has()
26 call assert_equal(1, has('eval'))
27 call assert_equal(1, has('eval', 1))
28
Bram Moolenaar0e05de42020-03-25 22:23:46 +010029 if has('unix')
30 call assert_equal(1, or(has('ttyin'), 1))
31 call assert_equal(0, and(has('ttyout'), 0))
32 call assert_equal(1, has('multi_byte_encoding'))
33 endif
Bram Moolenaar99fa7212020-04-26 15:59:55 +020034 call assert_equal(1, has('vcon', 1))
35 call assert_equal(1, has('mouse_gpm_enabled', 1))
Bram Moolenaar0e05de42020-03-25 22:23:46 +010036
Bram Moolenaar79296512020-03-22 16:17:14 +010037 call assert_equal(0, has('nonexistent'))
38 call assert_equal(0, has('nonexistent', 1))
Bram Moolenaar0e05de42020-03-25 22:23:46 +010039
40 " Will we ever have patch 9999?
41 let ver = 'patch-' .. v:version / 100 .. '.' .. v:version % 100 .. '.9999'
42 call assert_equal(0, has(ver))
Bram Moolenaarb0375d42022-06-30 11:03:39 +010043
44 " There actually isn't a patch 9.0.0, but this is more consistent.
45 call assert_equal(1, has('patch-9.0.0'))
Bram Moolenaar79296512020-03-22 16:17:14 +010046endfunc
47
Bram Moolenaar24c2e482017-01-29 15:45:12 +010048func Test_empty()
49 call assert_equal(1, empty(''))
50 call assert_equal(0, empty('a'))
51
52 call assert_equal(1, empty(0))
53 call assert_equal(1, empty(-0))
54 call assert_equal(0, empty(1))
55 call assert_equal(0, empty(-1))
56
Bram Moolenaar73e28dc2022-09-17 21:08:33 +010057 call assert_equal(1, empty(0.0))
58 call assert_equal(1, empty(-0.0))
59 call assert_equal(0, empty(1.0))
60 call assert_equal(0, empty(-1.0))
61 call assert_equal(0, empty(1.0/0.0))
62 call assert_equal(0, empty(0.0/0.0))
Bram Moolenaar24c2e482017-01-29 15:45:12 +010063
64 call assert_equal(1, empty([]))
65 call assert_equal(0, empty(['a']))
66
67 call assert_equal(1, empty({}))
68 call assert_equal(0, empty({'a':1}))
69
70 call assert_equal(1, empty(v:null))
71 call assert_equal(1, empty(v:none))
72 call assert_equal(1, empty(v:false))
73 call assert_equal(0, empty(v:true))
74
Bram Moolenaar41042f32017-03-09 12:09:32 +010075 if has('channel')
76 call assert_equal(1, empty(test_null_channel()))
77 endif
78 if has('job')
79 call assert_equal(1, empty(test_null_job()))
80 endif
81
Bram Moolenaar24c2e482017-01-29 15:45:12 +010082 call assert_equal(0, empty(function('Test_empty')))
Bram Moolenaar17aca702019-05-16 22:24:55 +020083 call assert_equal(0, empty(function('Test_empty', [0])))
Bram Moolenaar7c215c52020-02-29 13:43:27 +010084
85 call assert_fails("call empty(test_void())", 'E685:')
86 call assert_fails("call empty(test_unknown())", 'E685:')
Bram Moolenaar24c2e482017-01-29 15:45:12 +010087endfunc
88
Bram Moolenaardd589232020-02-29 17:38:12 +010089func Test_test_void()
Bram Moolenaar61a417b2021-06-15 22:54:28 +020090 call assert_fails('echo 1 == test_void()', 'E1031:')
Bram Moolenaar73e28dc2022-09-17 21:08:33 +010091 call assert_fails('echo 1.0 == test_void()', 'E1031:')
Bram Moolenaardd589232020-02-29 17:38:12 +010092 call assert_fails('let x = json_encode(test_void())', 'E685:')
93 call assert_fails('let x = copy(test_void())', 'E685:')
Bram Moolenaar61a417b2021-06-15 22:54:28 +020094 call assert_fails('let x = copy([test_void()])', 'E1031:')
Bram Moolenaardd589232020-02-29 17:38:12 +010095endfunc
96
Bram Moolenaar1840a7b2021-07-13 20:32:29 +020097func Test_islocked()
98 call assert_fails('call islocked(99)', 'E475:')
99 call assert_fails('call islocked("s: x")', 'E488:')
100endfunc
101
Bram Moolenaar24c2e482017-01-29 15:45:12 +0100102func Test_len()
103 call assert_equal(1, len(0))
104 call assert_equal(2, len(12))
105
106 call assert_equal(0, len(''))
107 call assert_equal(2, len('ab'))
108
109 call assert_equal(0, len([]))
Bram Moolenaar08f41572020-04-20 16:50:00 +0200110 call assert_equal(0, len(test_null_list()))
Bram Moolenaar24c2e482017-01-29 15:45:12 +0100111 call assert_equal(2, len([2, 1]))
112
113 call assert_equal(0, len({}))
Bram Moolenaar08f41572020-04-20 16:50:00 +0200114 call assert_equal(0, len(test_null_dict()))
Bram Moolenaar24c2e482017-01-29 15:45:12 +0100115 call assert_equal(2, len({'a': 1, 'b': 2}))
116
117 call assert_fails('call len(v:none)', 'E701:')
118 call assert_fails('call len({-> 0})', 'E701:')
119endfunc
120
121func Test_max()
122 call assert_equal(0, max([]))
123 call assert_equal(2, max([2]))
124 call assert_equal(2, max([1, 2]))
125 call assert_equal(2, max([1, 2, v:null]))
126
127 call assert_equal(0, max({}))
128 call assert_equal(2, max({'a':1, 'b':2}))
129
130 call assert_fails('call max(1)', 'E712:')
131 call assert_fails('call max(v:none)', 'E712:')
Bram Moolenaarab65fc72021-02-04 22:07:16 +0100132
133 " check we only get one error
134 call assert_fails('call max([#{}, [1]])', ['E728:', 'E728:'])
135 call assert_fails('call max(#{a: {}, b: [1]})', ['E728:', 'E728:'])
Bram Moolenaar24c2e482017-01-29 15:45:12 +0100136endfunc
137
138func Test_min()
139 call assert_equal(0, min([]))
140 call assert_equal(2, min([2]))
141 call assert_equal(1, min([1, 2]))
142 call assert_equal(0, min([1, 2, v:null]))
143
144 call assert_equal(0, min({}))
145 call assert_equal(1, min({'a':1, 'b':2}))
146
147 call assert_fails('call min(1)', 'E712:')
148 call assert_fails('call min(v:none)', 'E712:')
Yegappan Lakshmanan34fcb692021-05-25 20:14:00 +0200149 call assert_fails('call min([1, {}])', 'E728:')
Bram Moolenaarab65fc72021-02-04 22:07:16 +0100150
151 " check we only get one error
152 call assert_fails('call min([[1], #{}])', ['E745:', 'E745:'])
153 call assert_fails('call min(#{a: [1], b: #{}})', ['E745:', 'E745:'])
Bram Moolenaar24c2e482017-01-29 15:45:12 +0100154endfunc
155
Bram Moolenaar42ab17b2018-05-20 14:11:10 +0200156func Test_strwidth()
157 for aw in ['single', 'double']
158 exe 'set ambiwidth=' . aw
159 call assert_equal(0, strwidth(''))
160 call assert_equal(1, strwidth("\t"))
161 call assert_equal(3, strwidth('Vim'))
162 call assert_equal(4, strwidth(1234))
163 call assert_equal(5, strwidth(-1234))
164
Bram Moolenaar30276f22019-01-24 17:59:39 +0100165 call assert_equal(2, strwidth('😉'))
166 call assert_equal(17, strwidth('Eĥoŝanĝo ĉiuĵaŭde'))
167 call assert_equal((aw == 'single') ? 6 : 7, strwidth('Straße'))
Bram Moolenaar42ab17b2018-05-20 14:11:10 +0200168
169 call assert_fails('call strwidth({->0})', 'E729:')
170 call assert_fails('call strwidth([])', 'E730:')
171 call assert_fails('call strwidth({})', 'E731:')
Bram Moolenaar42ab17b2018-05-20 14:11:10 +0200172 endfor
173
Bram Moolenaar73e28dc2022-09-17 21:08:33 +0100174 call assert_equal(3, strwidth(1.2))
175 call v9.CheckDefAndScriptFailure(['echo strwidth(1.2)'], ['E1013: Argument 1: type mismatch, expected string but got float', 'E1174: String required for argument 1'])
Bram Moolenaar3cfa5b12021-06-06 14:14:39 +0200176
Bram Moolenaar42ab17b2018-05-20 14:11:10 +0200177 set ambiwidth&
178endfunc
179
Bram Moolenaar08243d22017-01-10 16:12:29 +0100180func Test_str2nr()
181 call assert_equal(0, str2nr(''))
182 call assert_equal(1, str2nr('1'))
183 call assert_equal(1, str2nr(' 1 '))
184
185 call assert_equal(1, str2nr('+1'))
186 call assert_equal(1, str2nr('+ 1'))
187 call assert_equal(1, str2nr(' + 1 '))
188
189 call assert_equal(-1, str2nr('-1'))
190 call assert_equal(-1, str2nr('- 1'))
191 call assert_equal(-1, str2nr(' - 1 '))
192
193 call assert_equal(123456789, str2nr('123456789'))
194 call assert_equal(-123456789, str2nr('-123456789'))
Bram Moolenaar24c2e482017-01-29 15:45:12 +0100195
196 call assert_equal(5, str2nr('101', 2))
Bram Moolenaarf6ed61e2019-09-07 19:05:09 +0200197 call assert_equal(5, '0b101'->str2nr(2))
Bram Moolenaar24c2e482017-01-29 15:45:12 +0100198 call assert_equal(5, str2nr('0B101', 2))
199 call assert_equal(-5, str2nr('-101', 2))
200 call assert_equal(-5, str2nr('-0b101', 2))
201 call assert_equal(-5, str2nr('-0B101', 2))
202
203 call assert_equal(65, str2nr('101', 8))
204 call assert_equal(65, str2nr('0101', 8))
205 call assert_equal(-65, str2nr('-101', 8))
206 call assert_equal(-65, str2nr('-0101', 8))
Bram Moolenaarc17e66c2020-06-02 21:38:22 +0200207 call assert_equal(65, str2nr('0o101', 8))
208 call assert_equal(65, str2nr('0O0101', 8))
209 call assert_equal(-65, str2nr('-0O101', 8))
210 call assert_equal(-65, str2nr('-0o0101', 8))
Bram Moolenaar24c2e482017-01-29 15:45:12 +0100211
212 call assert_equal(11259375, str2nr('abcdef', 16))
213 call assert_equal(11259375, str2nr('ABCDEF', 16))
214 call assert_equal(-11259375, str2nr('-ABCDEF', 16))
215 call assert_equal(11259375, str2nr('0xabcdef', 16))
216 call assert_equal(11259375, str2nr('0Xabcdef', 16))
217 call assert_equal(11259375, str2nr('0XABCDEF', 16))
218 call assert_equal(-11259375, str2nr('-0xABCDEF', 16))
219
Bram Moolenaar60a8de22019-09-15 14:33:22 +0200220 call assert_equal(1, str2nr("1'000'000", 10, 0))
221 call assert_equal(256, str2nr("1'0000'0000", 2, 1))
222 call assert_equal(262144, str2nr("1'000'000", 8, 1))
223 call assert_equal(1000000, str2nr("1'000'000", 10, 1))
Bram Moolenaarea8dcf82019-09-15 21:12:22 +0200224 call assert_equal(1000, str2nr("1'000''000", 10, 1))
Bram Moolenaar60a8de22019-09-15 14:33:22 +0200225 call assert_equal(65536, str2nr("1'00'00", 16, 1))
226
Bram Moolenaar24c2e482017-01-29 15:45:12 +0100227 call assert_equal(0, str2nr('0x10'))
228 call assert_equal(0, str2nr('0b10'))
Bram Moolenaarc17e66c2020-06-02 21:38:22 +0200229 call assert_equal(0, str2nr('0o10'))
Bram Moolenaar24c2e482017-01-29 15:45:12 +0100230 call assert_equal(1, str2nr('12', 2))
231 call assert_equal(1, str2nr('18', 8))
232 call assert_equal(1, str2nr('1g', 16))
233
234 call assert_equal(0, str2nr(v:null))
235 call assert_equal(0, str2nr(v:none))
236
237 call assert_fails('call str2nr([])', 'E730:')
238 call assert_fails('call str2nr({->2})', 'E729:')
Bram Moolenaar73e28dc2022-09-17 21:08:33 +0100239 call assert_equal(1, str2nr(1.2))
240 call v9.CheckDefAndScriptFailure(['echo str2nr(1.2)'], ['E1013: Argument 1: type mismatch, expected string but got float', 'E1174: String required for argument 1'])
Bram Moolenaar9b7bf9e2020-07-11 22:14:59 +0200241 call assert_fails('call str2nr(10, [])', 'E745:')
Bram Moolenaar24c2e482017-01-29 15:45:12 +0100242endfunc
243
244func Test_strftime()
Bram Moolenaar10455d42019-11-21 15:36:18 +0100245 CheckFunction strftime
246
Bram Moolenaar24c2e482017-01-29 15:45:12 +0100247 " Format of strftime() depends on system. We assume
248 " that basic formats tested here are available and
249 " identical on all systems which support strftime().
250 "
251 " The 2nd parameter of strftime() is a local time, so the output day
252 " of strftime() can be 17 or 18, depending on timezone.
253 call assert_match('^2017-01-1[78]$', strftime('%Y-%m-%d', 1484695512))
254 "
Bram Moolenaarf6ed61e2019-09-07 19:05:09 +0200255 call assert_match('^\d\d\d\d-\(0\d\|1[012]\)-\([012]\d\|3[01]\) \([01]\d\|2[0-3]\):[0-5]\d:\([0-5]\d\|60\)$', '%Y-%m-%d %H:%M:%S'->strftime())
Bram Moolenaar24c2e482017-01-29 15:45:12 +0100256
257 call assert_fails('call strftime([])', 'E730:')
258 call assert_fails('call strftime("%Y", [])', 'E745:')
Bram Moolenaardb517302019-06-18 22:53:24 +0200259
260 " Check that the time changes after we change the timezone
261 " Save previous timezone value, if any
262 if exists('$TZ')
263 let tz = $TZ
264 endif
265
266 " Force EST and then UTC, save the current hour (24-hour clock) for each
267 let $TZ = 'EST' | let est = strftime('%H')
268 let $TZ = 'UTC' | let utc = strftime('%H')
269
270 " Those hours should be two bytes long, and should not be the same; if they
271 " are, a tzset(3) call may have failed somewhere
272 call assert_equal(strlen(est), 2)
273 call assert_equal(strlen(utc), 2)
Bram Moolenaar87652a72019-06-18 23:07:37 +0200274 " TODO: this fails on MS-Windows
275 if has('unix')
276 call assert_notequal(est, utc)
277 endif
Bram Moolenaardb517302019-06-18 22:53:24 +0200278
279 " If we cached a timezone value, put it back, otherwise clear it
280 if exists('tz')
281 let $TZ = tz
282 else
283 unlet $TZ
284 endif
Bram Moolenaar10455d42019-11-21 15:36:18 +0100285endfunc
Bram Moolenaardb517302019-06-18 22:53:24 +0200286
Bram Moolenaar10455d42019-11-21 15:36:18 +0100287func Test_strptime()
288 CheckFunction strptime
289
290 if exists('$TZ')
291 let tz = $TZ
292 endif
293 let $TZ = 'UTC'
294
Bram Moolenaar9a838fe2019-12-06 12:45:01 +0100295 call assert_equal(1484653763, strptime('%Y-%m-%d %T', '2017-01-17 11:49:23'))
Bram Moolenaar10455d42019-11-21 15:36:18 +0100296
Bram Moolenaarea1233f2020-06-10 16:54:13 +0200297 " Force DST and check that it's considered
298 let $TZ = 'WINTER0SUMMER,J1,J365'
299 call assert_equal(1484653763 - 3600, strptime('%Y-%m-%d %T', '2017-01-17 11:49:23'))
300
Bram Moolenaar10455d42019-11-21 15:36:18 +0100301 call assert_fails('call strptime()', 'E119:')
302 call assert_fails('call strptime("xxx")', 'E119:')
303 call assert_equal(0, strptime("%Y", ''))
304 call assert_equal(0, strptime("%Y", "xxx"))
305
306 if exists('tz')
307 let $TZ = tz
308 else
309 unlet $TZ
310 endif
Bram Moolenaar24c2e482017-01-29 15:45:12 +0100311endfunc
312
Bram Moolenaardce1e892019-02-10 23:18:53 +0100313func Test_resolve_unix()
Bram Moolenaar6d91bcb2020-08-12 18:50:36 +0200314 CheckUnix
Bram Moolenaar26109902018-10-06 15:43:17 +0200315
316 " Xlink1 -> Xlink2
317 " Xlink2 -> Xlink3
318 silent !ln -s -f Xlink2 Xlink1
319 silent !ln -s -f Xlink3 Xlink2
320 call assert_equal('Xlink3', resolve('Xlink1'))
321 call assert_equal('./Xlink3', resolve('./Xlink1'))
322 call assert_equal('Xlink3/', resolve('Xlink2/'))
323 " FIXME: these tests result in things like "Xlink2/" instead of "Xlink3/"?!
324 "call assert_equal('Xlink3/', resolve('Xlink1/'))
325 "call assert_equal('./Xlink3/', resolve('./Xlink1/'))
326 "call assert_equal(getcwd() . '/Xlink3/', resolve(getcwd() . '/Xlink1/'))
327 call assert_equal(getcwd() . '/Xlink3', resolve(getcwd() . '/Xlink1'))
328
329 " Test resolve() with a symlink cycle.
330 " Xlink1 -> Xlink2
331 " Xlink2 -> Xlink3
332 " Xlink3 -> Xlink1
333 silent !ln -s -f Xlink1 Xlink3
334 call assert_fails('call resolve("Xlink1")', 'E655:')
335 call assert_fails('call resolve("./Xlink1")', 'E655:')
336 call assert_fails('call resolve("Xlink2")', 'E655:')
337 call assert_fails('call resolve("Xlink3")', 'E655:')
338 call delete('Xlink1')
339 call delete('Xlink2')
340 call delete('Xlink3')
341
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +0100342 silent !ln -s -f Xresolvedir//Xfile Xresolvelink
343 call assert_equal('Xresolvedir/Xfile', resolve('Xresolvelink'))
344 call delete('Xresolvelink')
Bram Moolenaar26109902018-10-06 15:43:17 +0200345
346 silent !ln -s -f Xlink2/ Xlink1
Bram Moolenaara0d1fef2019-09-04 22:29:14 +0200347 call assert_equal('Xlink2', 'Xlink1'->resolve())
Bram Moolenaar26109902018-10-06 15:43:17 +0200348 call assert_equal('Xlink2/', resolve('Xlink1/'))
349 call delete('Xlink1')
350
351 silent !ln -s -f ./Xlink2 Xlink1
352 call assert_equal('Xlink2', resolve('Xlink1'))
353 call assert_equal('./Xlink2', resolve('./Xlink1'))
354 call delete('Xlink1')
Bram Moolenaar50c4e9e2020-10-05 20:38:06 +0200355
356 call assert_equal('/', resolve('/'))
Bram Moolenaar26109902018-10-06 15:43:17 +0200357endfunc
358
Bram Moolenaardce1e892019-02-10 23:18:53 +0100359func s:normalize_fname(fname)
360 let ret = substitute(a:fname, '\', '/', 'g')
361 let ret = substitute(ret, '//', '/', 'g')
Bram Moolenaarf92e58c2019-09-08 21:51:41 +0200362 return ret->tolower()
Bram Moolenaardce1e892019-02-10 23:18:53 +0100363endfunc
364
365func Test_resolve_win32()
Bram Moolenaar6d91bcb2020-08-12 18:50:36 +0200366 CheckMSWindows
Bram Moolenaardce1e892019-02-10 23:18:53 +0100367
368 " test for shortcut file
369 if executable('cscript')
Bram Moolenaarb18b4962022-09-02 21:55:50 +0100370 new Xresfile
Bram Moolenaardce1e892019-02-10 23:18:53 +0100371 wq
Bram Moolenaare7eb9272019-06-24 00:58:07 +0200372 let lines =<< trim END
373 Set fs = CreateObject("Scripting.FileSystemObject")
374 Set ws = WScript.CreateObject("WScript.Shell")
375 Set shortcut = ws.CreateShortcut("Xlink.lnk")
Bram Moolenaarb18b4962022-09-02 21:55:50 +0100376 shortcut.TargetPath = fs.BuildPath(ws.CurrentDirectory, "Xresfile")
Bram Moolenaare7eb9272019-06-24 00:58:07 +0200377 shortcut.Save
378 END
379 call writefile(lines, 'link.vbs')
Bram Moolenaardce1e892019-02-10 23:18:53 +0100380 silent !cscript link.vbs
381 call delete('link.vbs')
Bram Moolenaarb18b4962022-09-02 21:55:50 +0100382 call assert_equal(s:normalize_fname(getcwd() . '\Xresfile'), s:normalize_fname(resolve('./Xlink.lnk')))
383 call delete('Xresfile')
Bram Moolenaardce1e892019-02-10 23:18:53 +0100384
Bram Moolenaarb18b4962022-09-02 21:55:50 +0100385 call assert_equal(s:normalize_fname(getcwd() . '\Xresfile'), s:normalize_fname(resolve('./Xlink.lnk')))
Bram Moolenaardce1e892019-02-10 23:18:53 +0100386 call delete('Xlink.lnk')
387 else
388 echomsg 'skipped test for shortcut file'
389 endif
390
391 " remove files
392 call delete('Xlink')
Bram Moolenaar15cae5c2022-08-29 22:51:38 +0100393 call delete('Xdir', 'd')
Bram Moolenaarb18b4962022-09-02 21:55:50 +0100394 call delete('Xresfile')
Bram Moolenaardce1e892019-02-10 23:18:53 +0100395
396 " test for symbolic link to a file
Bram Moolenaarb18b4962022-09-02 21:55:50 +0100397 new Xresfile
Bram Moolenaardce1e892019-02-10 23:18:53 +0100398 wq
Bram Moolenaarb18b4962022-09-02 21:55:50 +0100399 call assert_equal('Xresfile', resolve('Xresfile'))
400 silent !mklink Xlink Xresfile
Bram Moolenaardce1e892019-02-10 23:18:53 +0100401 if !v:shell_error
Bram Moolenaarb18b4962022-09-02 21:55:50 +0100402 call assert_equal(s:normalize_fname(getcwd() . '\Xresfile'), s:normalize_fname(resolve('./Xlink')))
Bram Moolenaardce1e892019-02-10 23:18:53 +0100403 call delete('Xlink')
404 else
405 echomsg 'skipped test for symbolic link to a file'
406 endif
Bram Moolenaarb18b4962022-09-02 21:55:50 +0100407 call delete('Xresfile')
Bram Moolenaardce1e892019-02-10 23:18:53 +0100408
409 " test for junction to a directory
Bram Moolenaar15cae5c2022-08-29 22:51:38 +0100410 call mkdir('Xdir')
411 silent !mklink /J Xlink Xdir
Bram Moolenaardce1e892019-02-10 23:18:53 +0100412 if !v:shell_error
Bram Moolenaar15cae5c2022-08-29 22:51:38 +0100413 call assert_equal(s:normalize_fname(getcwd() . '\Xdir'), s:normalize_fname(resolve(getcwd() . '/Xlink')))
Bram Moolenaardce1e892019-02-10 23:18:53 +0100414
Bram Moolenaar15cae5c2022-08-29 22:51:38 +0100415 call delete('Xdir', 'd')
Bram Moolenaardce1e892019-02-10 23:18:53 +0100416
417 " test for junction already removed
418 call assert_equal(s:normalize_fname(getcwd() . '\Xlink'), s:normalize_fname(resolve(getcwd() . '/Xlink')))
419 call delete('Xlink')
420 else
421 echomsg 'skipped test for junction to a directory'
Bram Moolenaar15cae5c2022-08-29 22:51:38 +0100422 call delete('Xdir', 'd')
Bram Moolenaardce1e892019-02-10 23:18:53 +0100423 endif
424
425 " test for symbolic link to a directory
Bram Moolenaar15cae5c2022-08-29 22:51:38 +0100426 call mkdir('Xdir')
427 silent !mklink /D Xlink Xdir
Bram Moolenaardce1e892019-02-10 23:18:53 +0100428 if !v:shell_error
Bram Moolenaar15cae5c2022-08-29 22:51:38 +0100429 call assert_equal(s:normalize_fname(getcwd() . '\Xdir'), s:normalize_fname(resolve(getcwd() . '/Xlink')))
Bram Moolenaardce1e892019-02-10 23:18:53 +0100430
Bram Moolenaar15cae5c2022-08-29 22:51:38 +0100431 call delete('Xdir', 'd')
Bram Moolenaardce1e892019-02-10 23:18:53 +0100432
433 " test for symbolic link already removed
434 call assert_equal(s:normalize_fname(getcwd() . '\Xlink'), s:normalize_fname(resolve(getcwd() . '/Xlink')))
435 call delete('Xlink')
436 else
437 echomsg 'skipped test for symbolic link to a directory'
Bram Moolenaar15cae5c2022-08-29 22:51:38 +0100438 call delete('Xdir', 'd')
Bram Moolenaardce1e892019-02-10 23:18:53 +0100439 endif
440
441 " test for buffer name
Bram Moolenaarb18b4962022-09-02 21:55:50 +0100442 new Xbuffile
Bram Moolenaardce1e892019-02-10 23:18:53 +0100443 wq
Bram Moolenaarb18b4962022-09-02 21:55:50 +0100444 silent !mklink Xlink Xbuffile
Bram Moolenaardce1e892019-02-10 23:18:53 +0100445 if !v:shell_error
446 edit Xlink
447 call assert_equal('Xlink', bufname('%'))
448 call delete('Xlink')
449 bw!
450 else
451 echomsg 'skipped test for buffer name'
452 endif
Bram Moolenaarb18b4962022-09-02 21:55:50 +0100453 call delete('Xbuffile')
Bram Moolenaar1bbebab2019-05-29 20:36:54 +0200454
455 " test for reparse point
Bram Moolenaar15cae5c2022-08-29 22:51:38 +0100456 call mkdir('Xdir')
457 call assert_equal('Xdir', resolve('Xdir'))
458 silent !mklink /D Xdirlink Xdir
Bram Moolenaar1bbebab2019-05-29 20:36:54 +0200459 if !v:shell_error
Bram Moolenaar15cae5c2022-08-29 22:51:38 +0100460 w Xdir/text.txt
461 call assert_equal('Xdir/text.txt', resolve('Xdir/text.txt'))
462 call assert_equal(s:normalize_fname(getcwd() . '\Xdir\text.txt'), s:normalize_fname(resolve('Xdirlink\text.txt')))
463 call assert_equal(s:normalize_fname(getcwd() . '\Xdir'), s:normalize_fname(resolve('Xdirlink')))
Bram Moolenaar4a792c82019-06-06 12:22:41 +0200464 call delete('Xdirlink')
Bram Moolenaar1bbebab2019-05-29 20:36:54 +0200465 else
466 echomsg 'skipped test for reparse point'
467 endif
468
Bram Moolenaar15cae5c2022-08-29 22:51:38 +0100469 call delete('Xdir', 'rf')
Bram Moolenaardce1e892019-02-10 23:18:53 +0100470endfunc
471
Bram Moolenaar24c2e482017-01-29 15:45:12 +0100472func Test_simplify()
473 call assert_equal('', simplify(''))
474 call assert_equal('/', simplify('/'))
475 call assert_equal('/', simplify('/.'))
476 call assert_equal('/', simplify('/..'))
477 call assert_equal('/...', simplify('/...'))
Bram Moolenaarfdcbe3c2020-06-15 21:41:56 +0200478 call assert_equal('//path', simplify('//path'))
Bram Moolenaarc70222d2020-06-15 23:18:12 +0200479 if has('unix')
480 call assert_equal('/path', simplify('///path'))
481 call assert_equal('/path', simplify('////path'))
482 endif
Bram Moolenaarfdcbe3c2020-06-15 21:41:56 +0200483
Bram Moolenaar7035fd92020-04-08 20:03:52 +0200484 call assert_equal('./dir/file', './dir/file'->simplify())
Bram Moolenaar24c2e482017-01-29 15:45:12 +0100485 call assert_equal('./dir/file', simplify('.///dir//file'))
486 call assert_equal('./dir/file', simplify('./dir/./file'))
487 call assert_equal('./file', simplify('./dir/../file'))
488 call assert_equal('../dir/file', simplify('dir/../../dir/file'))
489 call assert_equal('./file', simplify('dir/.././file'))
Bram Moolenaarbdd2c292020-06-22 21:34:30 +0200490 call assert_equal('../dir', simplify('./../dir'))
491 call assert_equal('..', simplify('../testdir/..'))
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +0100492 call mkdir('Xsimpdir')
493 call assert_equal('.', simplify('Xsimpdir/../.'))
494 call delete('Xsimpdir', 'd')
Bram Moolenaar24c2e482017-01-29 15:45:12 +0100495
496 call assert_fails('call simplify({->0})', 'E729:')
497 call assert_fails('call simplify([])', 'E730:')
498 call assert_fails('call simplify({})', 'E731:')
Bram Moolenaar73e28dc2022-09-17 21:08:33 +0100499 call assert_equal('1.2', simplify(1.2))
500 call v9.CheckDefAndScriptFailure(['echo simplify(1.2)'], ['E1013: Argument 1: type mismatch, expected string but got float', 'E1174: String required for argument 1'])
Bram Moolenaar08243d22017-01-10 16:12:29 +0100501endfunc
Bram Moolenaarcc5b22b2017-01-26 22:51:56 +0100502
Bram Moolenaarbfde0b42018-08-08 22:27:31 +0200503func Test_pathshorten()
504 call assert_equal('', pathshorten(''))
505 call assert_equal('foo', pathshorten('foo'))
Bram Moolenaar3f4f3d82019-09-04 20:05:59 +0200506 call assert_equal('/foo', '/foo'->pathshorten())
Bram Moolenaarbfde0b42018-08-08 22:27:31 +0200507 call assert_equal('f/', pathshorten('foo/'))
508 call assert_equal('f/bar', pathshorten('foo/bar'))
Bram Moolenaar3f4f3d82019-09-04 20:05:59 +0200509 call assert_equal('f/b/foobar', 'foo/bar/foobar'->pathshorten())
Bram Moolenaarbfde0b42018-08-08 22:27:31 +0200510 call assert_equal('/f/b/foobar', pathshorten('/foo/bar/foobar'))
511 call assert_equal('.f/bar', pathshorten('.foo/bar'))
512 call assert_equal('~f/bar', pathshorten('~foo/bar'))
513 call assert_equal('~.f/bar', pathshorten('~.foo/bar'))
514 call assert_equal('.~f/bar', pathshorten('.~foo/bar'))
515 call assert_equal('~/f/bar', pathshorten('~/foo/bar'))
Bram Moolenaar92b83cc2020-04-25 15:24:44 +0200516 call assert_fails('call pathshorten([])', 'E730:')
Bram Moolenaar6a33ef02020-09-25 22:42:48 +0200517
518 " test pathshorten with optional variable to set preferred size of shortening
519 call assert_equal('', pathshorten('', 2))
520 call assert_equal('foo', pathshorten('foo', 2))
521 call assert_equal('/foo', pathshorten('/foo', 2))
522 call assert_equal('fo/', pathshorten('foo/', 2))
523 call assert_equal('fo/bar', pathshorten('foo/bar', 2))
524 call assert_equal('fo/ba/foobar', pathshorten('foo/bar/foobar', 2))
525 call assert_equal('/fo/ba/foobar', pathshorten('/foo/bar/foobar', 2))
526 call assert_equal('.fo/bar', pathshorten('.foo/bar', 2))
527 call assert_equal('~fo/bar', pathshorten('~foo/bar', 2))
528 call assert_equal('~.fo/bar', pathshorten('~.foo/bar', 2))
529 call assert_equal('.~fo/bar', pathshorten('.~foo/bar', 2))
530 call assert_equal('~/fo/bar', pathshorten('~/foo/bar', 2))
531 call assert_fails('call pathshorten([],2)', 'E730:')
532 call assert_notequal('~/fo/bar', pathshorten('~/foo/bar', 3))
533 call assert_equal('~/foo/bar', pathshorten('~/foo/bar', 3))
534 call assert_equal('~/f/bar', pathshorten('~/foo/bar', 0))
Bram Moolenaarbfde0b42018-08-08 22:27:31 +0200535endfunc
536
Bram Moolenaarc7d16dc2017-11-18 20:32:03 +0100537func Test_strpart()
538 call assert_equal('de', strpart('abcdefg', 3, 2))
539 call assert_equal('ab', strpart('abcdefg', -2, 4))
Bram Moolenaarf6ed61e2019-09-07 19:05:09 +0200540 call assert_equal('abcdefg', 'abcdefg'->strpart(-2))
Bram Moolenaarc7d16dc2017-11-18 20:32:03 +0100541 call assert_equal('fg', strpart('abcdefg', 5, 4))
542 call assert_equal('defg', strpart('abcdefg', 3))
Bram Moolenaar0e05de42020-03-25 22:23:46 +0100543 call assert_equal('', strpart('abcdefg', 10))
544 call assert_fails("let s=strpart('abcdef', [])", 'E745:')
Bram Moolenaarc7d16dc2017-11-18 20:32:03 +0100545
Bram Moolenaar30276f22019-01-24 17:59:39 +0100546 call assert_equal('lép', strpart('éléphant', 2, 4))
547 call assert_equal('léphant', strpart('éléphant', 2))
Bram Moolenaar6c53fca2020-08-23 17:34:46 +0200548
549 call assert_equal('é', strpart('éléphant', 0, 1, 1))
550 call assert_equal('ép', strpart('éléphant', 3, 2, v:true))
551 call assert_equal('ó', strpart('cómposed', 1, 1, 1))
Bram Moolenaarc7d16dc2017-11-18 20:32:03 +0100552endfunc
553
Bram Moolenaarcc5b22b2017-01-26 22:51:56 +0100554func Test_tolower()
555 call assert_equal("", tolower(""))
556
557 " Test with all printable ASCII characters.
558 call assert_equal(' !"#$%&''()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`abcdefghijklmnopqrstuvwxyz{|}~',
559 \ tolower(' !"#$%&''()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~'))
560
Bram Moolenaarcc5b22b2017-01-26 22:51:56 +0100561 " Test with a few uppercase diacritics.
562 call assert_equal("aàáâãäåāăąǎǟǡả", tolower("AÀÁÂÃÄÅĀĂĄǍǞǠẢ"))
563 call assert_equal("bḃḇ", tolower("BḂḆ"))
564 call assert_equal("cçćĉċč", tolower("CÇĆĈĊČ"))
565 call assert_equal("dďđḋḏḑ", tolower("DĎĐḊḎḐ"))
566 call assert_equal("eèéêëēĕėęěẻẽ", tolower("EÈÉÊËĒĔĖĘĚẺẼ"))
567 call assert_equal("f ", tolower("F "))
568 call assert_equal("gĝğġģǥǧǵḡ", tolower("GĜĞĠĢǤǦǴḠ"))
569 call assert_equal("hĥħḣḧḩ", tolower("HĤĦḢḦḨ"))
570 call assert_equal("iìíîïĩīĭįiǐỉ", tolower("IÌÍÎÏĨĪĬĮİǏỈ"))
571 call assert_equal("jĵ", tolower("JĴ"))
572 call assert_equal("kķǩḱḵ", tolower("KĶǨḰḴ"))
573 call assert_equal("lĺļľŀłḻ", tolower("LĹĻĽĿŁḺ"))
574 call assert_equal("mḿṁ", tolower("MḾṀ"))
575 call assert_equal("nñńņňṅṉ", tolower("NÑŃŅŇṄṈ"))
576 call assert_equal("oòóôõöøōŏőơǒǫǭỏ", tolower("OÒÓÔÕÖØŌŎŐƠǑǪǬỎ"))
577 call assert_equal("pṕṗ", tolower("PṔṖ"))
578 call assert_equal("q", tolower("Q"))
579 call assert_equal("rŕŗřṙṟ", tolower("RŔŖŘṘṞ"))
580 call assert_equal("sśŝşšṡ", tolower("SŚŜŞŠṠ"))
581 call assert_equal("tţťŧṫṯ", tolower("TŢŤŦṪṮ"))
582 call assert_equal("uùúûüũūŭůűųưǔủ", tolower("UÙÚÛÜŨŪŬŮŰŲƯǓỦ"))
583 call assert_equal("v", tolower("V"))
584 call assert_equal("wŵẁẃẅẇ", tolower("WŴẀẂẄẆ"))
585 call assert_equal("xẋẍ", tolower("XẊẌ"))
586 call assert_equal("yýŷÿẏỳỷỹ", tolower("YÝŶŸẎỲỶỸ"))
587 call assert_equal("zźżžƶẑẕ", tolower("ZŹŻŽƵẐẔ"))
588
589 " Test with a few lowercase diacritics, which should remain unchanged.
590 call assert_equal("aàáâãäåāăąǎǟǡả", tolower("aàáâãäåāăąǎǟǡả"))
591 call assert_equal("bḃḇ", tolower("bḃḇ"))
592 call assert_equal("cçćĉċč", tolower("cçćĉċč"))
593 call assert_equal("dďđḋḏḑ", tolower("dďđḋḏḑ"))
594 call assert_equal("eèéêëēĕėęěẻẽ", tolower("eèéêëēĕėęěẻẽ"))
595 call assert_equal("fḟ", tolower("fḟ"))
596 call assert_equal("gĝğġģǥǧǵḡ", tolower("gĝğġģǥǧǵḡ"))
597 call assert_equal("hĥħḣḧḩẖ", tolower("hĥħḣḧḩẖ"))
598 call assert_equal("iìíîïĩīĭįǐỉ", tolower("iìíîïĩīĭįǐỉ"))
599 call assert_equal("jĵǰ", tolower("jĵǰ"))
600 call assert_equal("kķǩḱḵ", tolower("kķǩḱḵ"))
601 call assert_equal("lĺļľŀłḻ", tolower("lĺļľŀłḻ"))
602 call assert_equal("mḿṁ ", tolower("mḿṁ "))
603 call assert_equal("nñńņňʼnṅṉ", tolower("nñńņňʼnṅṉ"))
604 call assert_equal("oòóôõöøōŏőơǒǫǭỏ", tolower("oòóôõöøōŏőơǒǫǭỏ"))
605 call assert_equal("pṕṗ", tolower("pṕṗ"))
606 call assert_equal("q", tolower("q"))
607 call assert_equal("rŕŗřṙṟ", tolower("rŕŗřṙṟ"))
608 call assert_equal("sśŝşšṡ", tolower("sśŝşšṡ"))
609 call assert_equal("tţťŧṫṯẗ", tolower("tţťŧṫṯẗ"))
610 call assert_equal("uùúûüũūŭůűųưǔủ", tolower("uùúûüũūŭůűųưǔủ"))
611 call assert_equal("vṽ", tolower("vṽ"))
612 call assert_equal("wŵẁẃẅẇẘ", tolower("wŵẁẃẅẇẘ"))
613 call assert_equal("ẋẍ", tolower("ẋẍ"))
614 call assert_equal("yýÿŷẏẙỳỷỹ", tolower("yýÿŷẏẙỳỷỹ"))
615 call assert_equal("zźżžƶẑẕ", tolower("zźżžƶẑẕ"))
616
617 " According to https://twitter.com/jifa/status/625776454479970304
618 " Ⱥ (U+023A) and Ⱦ (U+023E) are the *only* code points to increase
619 " in length (2 to 3 bytes) when lowercased. So let's test them.
620 call assert_equal(" ", tolower("Ⱥ Ⱦ"))
Bram Moolenaare6640ad2017-12-22 21:06:56 +0100621
622 " This call to tolower with invalid utf8 sequence used to cause access to
623 " invalid memory.
624 call tolower("\xC0\x80\xC0")
625 call tolower("123\xC0\x80\xC0")
Bram Moolenaar0ff5ded2020-05-07 18:43:44 +0200626
627 " Test in latin1 encoding
628 let save_enc = &encoding
629 set encoding=latin1
630 call assert_equal("abc", tolower("ABC"))
631 let &encoding = save_enc
Bram Moolenaarcc5b22b2017-01-26 22:51:56 +0100632endfunc
633
634func Test_toupper()
635 call assert_equal("", toupper(""))
636
637 " Test with all printable ASCII characters.
638 call assert_equal(' !"#$%&''()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~',
639 \ toupper(' !"#$%&''()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~'))
640
Bram Moolenaarcc5b22b2017-01-26 22:51:56 +0100641 " Test with a few lowercase diacritics.
Bram Moolenaarf92e58c2019-09-08 21:51:41 +0200642 call assert_equal("AÀÁÂÃÄÅĀĂĄǍǞǠẢ", "aàáâãäåāăąǎǟǡả"->toupper())
Bram Moolenaarcc5b22b2017-01-26 22:51:56 +0100643 call assert_equal("BḂḆ", toupper("bḃḇ"))
644 call assert_equal("CÇĆĈĊČ", toupper("cçćĉċč"))
645 call assert_equal("DĎĐḊḎḐ", toupper("dďđḋḏḑ"))
646 call assert_equal("EÈÉÊËĒĔĖĘĚẺẼ", toupper("eèéêëēĕėęěẻẽ"))
647 call assert_equal("F", toupper("f"))
648 call assert_equal("GĜĞĠĢǤǦǴḠ", toupper("gĝğġģǥǧǵḡ"))
649 call assert_equal("HĤĦḢḦḨẖ", toupper("hĥħḣḧḩẖ"))
650 call assert_equal("IÌÍÎÏĨĪĬĮǏỈ", toupper("iìíîïĩīĭįǐỉ"))
651 call assert_equal("JĴǰ", toupper("jĵǰ"))
652 call assert_equal("KĶǨḰḴ", toupper("kķǩḱḵ"))
653 call assert_equal("LĹĻĽĿŁḺ", toupper("lĺļľŀłḻ"))
654 call assert_equal("MḾṀ ", toupper("mḿṁ "))
655 call assert_equal("NÑŃŅŇʼnṄṈ", toupper("nñńņňʼnṅṉ"))
656 call assert_equal("OÒÓÔÕÖØŌŎŐƠǑǪǬỎ", toupper("oòóôõöøōŏőơǒǫǭỏ"))
657 call assert_equal("PṔṖ", toupper("pṕṗ"))
658 call assert_equal("Q", toupper("q"))
659 call assert_equal("RŔŖŘṘṞ", toupper("rŕŗřṙṟ"))
660 call assert_equal("SŚŜŞŠṠ", toupper("sśŝşšṡ"))
661 call assert_equal("TŢŤŦṪṮẗ", toupper("tţťŧṫṯẗ"))
662 call assert_equal("UÙÚÛÜŨŪŬŮŰŲƯǓỦ", toupper("uùúûüũūŭůűųưǔủ"))
663 call assert_equal("V", toupper("v"))
664 call assert_equal("WŴẀẂẄẆẘ", toupper("wŵẁẃẅẇẘ"))
665 call assert_equal("ẊẌ", toupper("ẋẍ"))
666 call assert_equal("YÝŸŶẎẙỲỶỸ", toupper("yýÿŷẏẙỳỷỹ"))
667 call assert_equal("ZŹŻŽƵẐẔ", toupper("zźżžƶẑẕ"))
668
669 " Test that uppercase diacritics, which should remain unchanged.
670 call assert_equal("AÀÁÂÃÄÅĀĂĄǍǞǠẢ", toupper("AÀÁÂÃÄÅĀĂĄǍǞǠẢ"))
671 call assert_equal("BḂḆ", toupper("BḂḆ"))
672 call assert_equal("CÇĆĈĊČ", toupper("CÇĆĈĊČ"))
673 call assert_equal("DĎĐḊḎḐ", toupper("DĎĐḊḎḐ"))
674 call assert_equal("EÈÉÊËĒĔĖĘĚẺẼ", toupper("EÈÉÊËĒĔĖĘĚẺẼ"))
675 call assert_equal("FḞ ", toupper("FḞ "))
676 call assert_equal("GĜĞĠĢǤǦǴḠ", toupper("GĜĞĠĢǤǦǴḠ"))
677 call assert_equal("HĤĦḢḦḨ", toupper("HĤĦḢḦḨ"))
678 call assert_equal("IÌÍÎÏĨĪĬĮİǏỈ", toupper("IÌÍÎÏĨĪĬĮİǏỈ"))
679 call assert_equal("JĴ", toupper("JĴ"))
680 call assert_equal("KĶǨḰḴ", toupper("KĶǨḰḴ"))
681 call assert_equal("LĹĻĽĿŁḺ", toupper("LĹĻĽĿŁḺ"))
682 call assert_equal("MḾṀ", toupper("MḾṀ"))
683 call assert_equal("NÑŃŅŇṄṈ", toupper("NÑŃŅŇṄṈ"))
684 call assert_equal("OÒÓÔÕÖØŌŎŐƠǑǪǬỎ", toupper("OÒÓÔÕÖØŌŎŐƠǑǪǬỎ"))
685 call assert_equal("PṔṖ", toupper("PṔṖ"))
686 call assert_equal("Q", toupper("Q"))
687 call assert_equal("RŔŖŘṘṞ", toupper("RŔŖŘṘṞ"))
688 call assert_equal("SŚŜŞŠṠ", toupper("SŚŜŞŠṠ"))
689 call assert_equal("TŢŤŦṪṮ", toupper("TŢŤŦṪṮ"))
690 call assert_equal("UÙÚÛÜŨŪŬŮŰŲƯǓỦ", toupper("UÙÚÛÜŨŪŬŮŰŲƯǓỦ"))
691 call assert_equal("VṼ", toupper("VṼ"))
692 call assert_equal("WŴẀẂẄẆ", toupper("WŴẀẂẄẆ"))
693 call assert_equal("XẊẌ", toupper("XẊẌ"))
694 call assert_equal("YÝŶŸẎỲỶỸ", toupper("YÝŶŸẎỲỶỸ"))
695 call assert_equal("ZŹŻŽƵẐẔ", toupper("ZŹŻŽƵẐẔ"))
696
Bram Moolenaar24c2e482017-01-29 15:45:12 +0100697 call assert_equal("Ⱥ Ⱦ", toupper("ⱥ ⱦ"))
Bram Moolenaare6640ad2017-12-22 21:06:56 +0100698
699 " This call to toupper with invalid utf8 sequence used to cause access to
700 " invalid memory.
701 call toupper("\xC0\x80\xC0")
702 call toupper("123\xC0\x80\xC0")
Bram Moolenaar0ff5ded2020-05-07 18:43:44 +0200703
704 " Test in latin1 encoding
705 let save_enc = &encoding
706 set encoding=latin1
707 call assert_equal("ABC", toupper("abc"))
708 let &encoding = save_enc
Bram Moolenaarcc5b22b2017-01-26 22:51:56 +0100709endfunc
710
Bram Moolenaarf92e58c2019-09-08 21:51:41 +0200711func Test_tr()
712 call assert_equal('foo', tr('bar', 'bar', 'foo'))
713 call assert_equal('zxy', 'cab'->tr('abc', 'xyz'))
Bram Moolenaar0e05de42020-03-25 22:23:46 +0100714 call assert_fails("let s=tr([], 'abc', 'def')", 'E730:')
715 call assert_fails("let s=tr('abc', [], 'def')", 'E730:')
716 call assert_fails("let s=tr('abc', 'abc', [])", 'E730:')
717 call assert_fails("let s=tr('abcd', 'abcd', 'def')", 'E475:')
718 set encoding=latin1
719 call assert_fails("let s=tr('abcd', 'abcd', 'def')", 'E475:')
720 call assert_equal('hEllO', tr('hello', 'eo', 'EO'))
721 call assert_equal('hello', tr('hello', 'xy', 'ab'))
Yegappan Lakshmanan34fcb692021-05-25 20:14:00 +0200722 call assert_fails('call tr("abc", "123", "₁₂")', 'E475:')
Bram Moolenaar0e05de42020-03-25 22:23:46 +0100723 set encoding=utf8
Bram Moolenaarf92e58c2019-09-08 21:51:41 +0200724endfunc
725
Bram Moolenaare90858d2017-02-01 17:24:34 +0100726" Tests for the mode() function
727let current_modes = ''
Bram Moolenaarffea8c92017-03-13 20:37:15 +0100728func Save_mode()
Bram Moolenaare90858d2017-02-01 17:24:34 +0100729 let g:current_modes = mode(0) . '-' . mode(1)
730 return ''
731endfunc
Bram Moolenaarcc5b22b2017-01-26 22:51:56 +0100732
Bram Moolenaarcde0ff32020-04-04 14:00:39 +0200733" Test for the mode() function
Bram Moolenaarffea8c92017-03-13 20:37:15 +0100734func Test_mode()
Bram Moolenaare90858d2017-02-01 17:24:34 +0100735 new
736 call append(0, ["Blue Ball Black", "Brown Band Bowl", ""])
737
Bram Moolenaarffea8c92017-03-13 20:37:15 +0100738 " Only complete from the current buffer.
739 set complete=.
740
Bram Moolenaare90858d2017-02-01 17:24:34 +0100741 inoremap <F2> <C-R>=Save_mode()<CR>
zeertzjqeaf3f362021-07-28 16:51:53 +0200742 xnoremap <F2> <Cmd>call Save_mode()<CR>
Bram Moolenaare90858d2017-02-01 17:24:34 +0100743
744 normal! 3G
745 exe "normal i\<F2>\<Esc>"
746 call assert_equal('i-i', g:current_modes)
Bram Moolenaare971df32017-02-05 14:15:29 +0100747 " i_CTRL-P: Multiple matches
Bram Moolenaare90858d2017-02-01 17:24:34 +0100748 exe "normal i\<C-G>uBa\<C-P>\<F2>\<Esc>u"
749 call assert_equal('i-ic', g:current_modes)
Bram Moolenaare971df32017-02-05 14:15:29 +0100750 " i_CTRL-P: Single match
Bram Moolenaare90858d2017-02-01 17:24:34 +0100751 exe "normal iBro\<C-P>\<F2>\<Esc>u"
752 call assert_equal('i-ic', g:current_modes)
Bram Moolenaare971df32017-02-05 14:15:29 +0100753 " i_CTRL-X
Bram Moolenaare90858d2017-02-01 17:24:34 +0100754 exe "normal iBa\<C-X>\<F2>\<Esc>u"
755 call assert_equal('i-ix', g:current_modes)
Bram Moolenaare971df32017-02-05 14:15:29 +0100756 " i_CTRL-X CTRL-P: Multiple matches
Bram Moolenaare90858d2017-02-01 17:24:34 +0100757 exe "normal iBa\<C-X>\<C-P>\<F2>\<Esc>u"
758 call assert_equal('i-ic', g:current_modes)
Bram Moolenaare971df32017-02-05 14:15:29 +0100759 " i_CTRL-X CTRL-P: Single match
Bram Moolenaare90858d2017-02-01 17:24:34 +0100760 exe "normal iBro\<C-X>\<C-P>\<F2>\<Esc>u"
761 call assert_equal('i-ic', g:current_modes)
Bram Moolenaare971df32017-02-05 14:15:29 +0100762 " i_CTRL-X CTRL-P + CTRL-P: Single match
Bram Moolenaare90858d2017-02-01 17:24:34 +0100763 exe "normal iBro\<C-X>\<C-P>\<C-P>\<F2>\<Esc>u"
764 call assert_equal('i-ic', g:current_modes)
Bram Moolenaare971df32017-02-05 14:15:29 +0100765 " i_CTRL-X CTRL-L: Multiple matches
766 exe "normal i\<C-X>\<C-L>\<F2>\<Esc>u"
767 call assert_equal('i-ic', g:current_modes)
768 " i_CTRL-X CTRL-L: Single match
769 exe "normal iBlu\<C-X>\<C-L>\<F2>\<Esc>u"
770 call assert_equal('i-ic', g:current_modes)
771 " i_CTRL-P: No match
Bram Moolenaare90858d2017-02-01 17:24:34 +0100772 exe "normal iCom\<C-P>\<F2>\<Esc>u"
773 call assert_equal('i-ic', g:current_modes)
Bram Moolenaare971df32017-02-05 14:15:29 +0100774 " i_CTRL-X CTRL-P: No match
Bram Moolenaare90858d2017-02-01 17:24:34 +0100775 exe "normal iCom\<C-X>\<C-P>\<F2>\<Esc>u"
776 call assert_equal('i-ic', g:current_modes)
Bram Moolenaare971df32017-02-05 14:15:29 +0100777 " i_CTRL-X CTRL-L: No match
778 exe "normal iabc\<C-X>\<C-L>\<F2>\<Esc>u"
779 call assert_equal('i-ic', g:current_modes)
Bram Moolenaare90858d2017-02-01 17:24:34 +0100780
zeertzjqcc8cd442021-10-03 15:19:14 +0100781 exe "normal R\<F2>\<Esc>"
782 call assert_equal('R-R', g:current_modes)
Bram Moolenaare971df32017-02-05 14:15:29 +0100783 " R_CTRL-P: Multiple matches
Bram Moolenaare90858d2017-02-01 17:24:34 +0100784 exe "normal RBa\<C-P>\<F2>\<Esc>u"
785 call assert_equal('R-Rc', g:current_modes)
Bram Moolenaare971df32017-02-05 14:15:29 +0100786 " R_CTRL-P: Single match
Bram Moolenaare90858d2017-02-01 17:24:34 +0100787 exe "normal RBro\<C-P>\<F2>\<Esc>u"
788 call assert_equal('R-Rc', g:current_modes)
Bram Moolenaare971df32017-02-05 14:15:29 +0100789 " R_CTRL-X
Bram Moolenaare90858d2017-02-01 17:24:34 +0100790 exe "normal RBa\<C-X>\<F2>\<Esc>u"
791 call assert_equal('R-Rx', g:current_modes)
Bram Moolenaare971df32017-02-05 14:15:29 +0100792 " R_CTRL-X CTRL-P: Multiple matches
Bram Moolenaare90858d2017-02-01 17:24:34 +0100793 exe "normal RBa\<C-X>\<C-P>\<F2>\<Esc>u"
794 call assert_equal('R-Rc', g:current_modes)
Bram Moolenaare971df32017-02-05 14:15:29 +0100795 " R_CTRL-X CTRL-P: Single match
Bram Moolenaare90858d2017-02-01 17:24:34 +0100796 exe "normal RBro\<C-X>\<C-P>\<F2>\<Esc>u"
797 call assert_equal('R-Rc', g:current_modes)
Bram Moolenaare971df32017-02-05 14:15:29 +0100798 " R_CTRL-X CTRL-P + CTRL-P: Single match
Bram Moolenaare90858d2017-02-01 17:24:34 +0100799 exe "normal RBro\<C-X>\<C-P>\<C-P>\<F2>\<Esc>u"
800 call assert_equal('R-Rc', g:current_modes)
Bram Moolenaare971df32017-02-05 14:15:29 +0100801 " R_CTRL-X CTRL-L: Multiple matches
802 exe "normal R\<C-X>\<C-L>\<F2>\<Esc>u"
803 call assert_equal('R-Rc', g:current_modes)
804 " R_CTRL-X CTRL-L: Single match
805 exe "normal RBlu\<C-X>\<C-L>\<F2>\<Esc>u"
806 call assert_equal('R-Rc', g:current_modes)
807 " R_CTRL-P: No match
Bram Moolenaare90858d2017-02-01 17:24:34 +0100808 exe "normal RCom\<C-P>\<F2>\<Esc>u"
809 call assert_equal('R-Rc', g:current_modes)
Bram Moolenaare971df32017-02-05 14:15:29 +0100810 " R_CTRL-X CTRL-P: No match
Bram Moolenaare90858d2017-02-01 17:24:34 +0100811 exe "normal RCom\<C-X>\<C-P>\<F2>\<Esc>u"
812 call assert_equal('R-Rc', g:current_modes)
Bram Moolenaare971df32017-02-05 14:15:29 +0100813 " R_CTRL-X CTRL-L: No match
814 exe "normal Rabc\<C-X>\<C-L>\<F2>\<Esc>u"
815 call assert_equal('R-Rc', g:current_modes)
Bram Moolenaare90858d2017-02-01 17:24:34 +0100816
zeertzjqcc8cd442021-10-03 15:19:14 +0100817 exe "normal gR\<F2>\<Esc>"
818 call assert_equal('R-Rv', g:current_modes)
819 " gR_CTRL-P: Multiple matches
820 exe "normal gRBa\<C-P>\<F2>\<Esc>u"
821 call assert_equal('R-Rvc', g:current_modes)
822 " gR_CTRL-P: Single match
823 exe "normal gRBro\<C-P>\<F2>\<Esc>u"
824 call assert_equal('R-Rvc', g:current_modes)
825 " gR_CTRL-X
826 exe "normal gRBa\<C-X>\<F2>\<Esc>u"
827 call assert_equal('R-Rvx', g:current_modes)
828 " gR_CTRL-X CTRL-P: Multiple matches
829 exe "normal gRBa\<C-X>\<C-P>\<F2>\<Esc>u"
830 call assert_equal('R-Rvc', g:current_modes)
831 " gR_CTRL-X CTRL-P: Single match
832 exe "normal gRBro\<C-X>\<C-P>\<F2>\<Esc>u"
833 call assert_equal('R-Rvc', g:current_modes)
834 " gR_CTRL-X CTRL-P + CTRL-P: Single match
835 exe "normal gRBro\<C-X>\<C-P>\<C-P>\<F2>\<Esc>u"
836 call assert_equal('R-Rvc', g:current_modes)
837 " gR_CTRL-X CTRL-L: Multiple matches
838 exe "normal gR\<C-X>\<C-L>\<F2>\<Esc>u"
839 call assert_equal('R-Rvc', g:current_modes)
840 " gR_CTRL-X CTRL-L: Single match
841 exe "normal gRBlu\<C-X>\<C-L>\<F2>\<Esc>u"
842 call assert_equal('R-Rvc', g:current_modes)
843 " gR_CTRL-P: No match
844 exe "normal gRCom\<C-P>\<F2>\<Esc>u"
845 call assert_equal('R-Rvc', g:current_modes)
846 " gR_CTRL-X CTRL-P: No match
847 exe "normal gRCom\<C-X>\<C-P>\<F2>\<Esc>u"
848 call assert_equal('R-Rvc', g:current_modes)
849 " gR_CTRL-X CTRL-L: No match
850 exe "normal gRabc\<C-X>\<C-L>\<F2>\<Esc>u"
851 call assert_equal('R-Rvc', g:current_modes)
852
Bram Moolenaara1449832019-09-01 20:16:52 +0200853 call assert_equal('n', 0->mode())
854 call assert_equal('n', 1->mode())
Bram Moolenaare90858d2017-02-01 17:24:34 +0100855
Bram Moolenaar612cc382018-07-29 15:34:26 +0200856 " i_CTRL-O
857 exe "normal i\<C-O>:call Save_mode()\<Cr>\<Esc>"
858 call assert_equal("n-niI", g:current_modes)
859
860 " R_CTRL-O
861 exe "normal R\<C-O>:call Save_mode()\<Cr>\<Esc>"
862 call assert_equal("n-niR", g:current_modes)
863
864 " gR_CTRL-O
865 exe "normal gR\<C-O>:call Save_mode()\<Cr>\<Esc>"
866 call assert_equal("n-niV", g:current_modes)
867
Bram Moolenaare90858d2017-02-01 17:24:34 +0100868 " How to test operator-pending mode?
869
870 call feedkeys("v", 'xt')
871 call assert_equal('v', mode())
872 call assert_equal('v', mode(1))
873 call feedkeys("\<Esc>V", 'xt')
874 call assert_equal('V', mode())
875 call assert_equal('V', mode(1))
876 call feedkeys("\<Esc>\<C-V>", 'xt')
877 call assert_equal("\<C-V>", mode())
878 call assert_equal("\<C-V>", mode(1))
879 call feedkeys("\<Esc>", 'xt')
880
881 call feedkeys("gh", 'xt')
882 call assert_equal('s', mode())
883 call assert_equal('s', mode(1))
884 call feedkeys("\<Esc>gH", 'xt')
885 call assert_equal('S', mode())
886 call assert_equal('S', mode(1))
887 call feedkeys("\<Esc>g\<C-H>", 'xt')
888 call assert_equal("\<C-S>", mode())
889 call assert_equal("\<C-S>", mode(1))
890 call feedkeys("\<Esc>", 'xt')
891
zeertzjqeaf3f362021-07-28 16:51:53 +0200892 " v_CTRL-O
893 exe "normal gh\<C-O>\<F2>\<Esc>"
894 call assert_equal("v-vs", g:current_modes)
895 exe "normal gH\<C-O>\<F2>\<Esc>"
896 call assert_equal("V-Vs", g:current_modes)
897 exe "normal g\<C-H>\<C-O>\<F2>\<Esc>"
898 call assert_equal("\<C-V>-\<C-V>s", g:current_modes)
899
Bram Moolenaare90858d2017-02-01 17:24:34 +0100900 call feedkeys(":echo \<C-R>=Save_mode()\<C-U>\<CR>", 'xt')
901 call assert_equal('c-c', g:current_modes)
902 call feedkeys("gQecho \<C-R>=Save_mode()\<CR>\<CR>vi\<CR>", 'xt')
903 call assert_equal('c-cv', g:current_modes)
Bram Moolenaarcde0ff32020-04-04 14:00:39 +0200904 call feedkeys("Qcall Save_mode()\<CR>vi\<CR>", 'xt')
905 call assert_equal('c-ce', g:current_modes)
Bram Moolenaare90858d2017-02-01 17:24:34 +0100906 " How to test Ex mode?
907
naohiro ono75c30e92021-10-19 11:15:41 +0100908 " Test mode in operatorfunc (it used to be Operator-pending).
909 set operatorfunc=OperatorFunc
910 function OperatorFunc(_)
911 call Save_mode()
912 endfunction
913 execute "normal! g@l\<Esc>"
914 call assert_equal('n-n', g:current_modes)
915 execute "normal! i\<C-o>g@l\<Esc>"
916 call assert_equal('n-niI', g:current_modes)
917 execute "normal! R\<C-o>g@l\<Esc>"
918 call assert_equal('n-niR', g:current_modes)
919 execute "normal! gR\<C-o>g@l\<Esc>"
920 call assert_equal('n-niV', g:current_modes)
921
Bram Moolenaar72406a42021-10-02 16:34:55 +0100922 if has('terminal')
923 term
924 call feedkeys("\<C-W>N", 'xt')
925 call assert_equal('n', mode())
926 call assert_equal('nt', mode(1))
927 call feedkeys("aexit\<CR>", 'xt')
928 endif
929
Bram Moolenaare90858d2017-02-01 17:24:34 +0100930 bwipe!
931 iunmap <F2>
zeertzjqeaf3f362021-07-28 16:51:53 +0200932 xunmap <F2>
Bram Moolenaarffea8c92017-03-13 20:37:15 +0100933 set complete&
naohiro ono75c30e92021-10-19 11:15:41 +0100934 set operatorfunc&
935 delfunction OperatorFunc
Bram Moolenaare90858d2017-02-01 17:24:34 +0100936endfunc
Bram Moolenaar79518e22017-02-17 16:31:35 +0100937
Bram Moolenaarad48e6c2020-04-21 22:19:45 +0200938" Test for append()
Bram Moolenaard2007022019-08-27 21:56:06 +0200939func Test_append()
940 enew!
941 split
Bram Moolenaarcd9c8d42022-11-05 23:46:43 +0000942 call assert_equal(0, append(1, []))
943 call assert_equal(0, append(1, test_null_list()))
944 call assert_equal(0, append(0, ["foo"]))
945 call assert_equal(0, append(1, []))
946 call assert_equal(0, append(1, test_null_list()))
947 call assert_equal(0, append(8, []))
948 call assert_equal(0, append(9, test_null_list()))
Bram Moolenaarad48e6c2020-04-21 22:19:45 +0200949 call assert_equal(['foo', ''], getline(1, '$'))
Bram Moolenaard2007022019-08-27 21:56:06 +0200950 split
951 only
952 undo
Bram Moolenaarad48e6c2020-04-21 22:19:45 +0200953 undo
Bram Moolenaar08f41572020-04-20 16:50:00 +0200954
955 " Using $ instead of '$' must give an error
956 call assert_fails("call append($, 'foobar')", 'E116:')
Bram Moolenaar801cd352022-10-10 16:08:16 +0100957
958 call assert_fails("call append({}, '')", ['E728:', 'E728:'])
Bram Moolenaard2007022019-08-27 21:56:06 +0200959endfunc
960
Bram Moolenaarad48e6c2020-04-21 22:19:45 +0200961" Test for setline()
962func Test_setline()
963 new
964 call setline(0, ["foo"])
965 call setline(0, [])
966 call setline(0, test_null_list())
967 call setline(1, ["bar"])
968 call setline(1, [])
969 call setline(1, test_null_list())
970 call setline(2, [])
971 call setline(2, test_null_list())
972 call setline(3, [])
973 call setline(3, test_null_list())
974 call setline(2, ["baz"])
975 call assert_equal(['bar', 'baz'], getline(1, '$'))
976 close!
977endfunc
978
Bram Moolenaar79518e22017-02-17 16:31:35 +0100979func Test_getbufvar()
980 let bnr = bufnr('%')
981 let b:var_num = '1234'
982 let def_num = '5678'
983 call assert_equal('1234', getbufvar(bnr, 'var_num'))
984 call assert_equal('1234', getbufvar(bnr, 'var_num', def_num))
985
986 let bd = getbufvar(bnr, '')
987 call assert_equal('1234', bd['var_num'])
988 call assert_true(exists("bd['changedtick']"))
989 call assert_equal(2, len(bd))
990
991 let bd2 = getbufvar(bnr, '', def_num)
992 call assert_equal(bd, bd2)
993
994 unlet b:var_num
995 call assert_equal(def_num, getbufvar(bnr, 'var_num', def_num))
996 call assert_equal('', getbufvar(bnr, 'var_num'))
997
998 let bd = getbufvar(bnr, '')
999 call assert_equal(1, len(bd))
1000 let bd = getbufvar(bnr, '',def_num)
1001 call assert_equal(1, len(bd))
1002
Bram Moolenaar4520d442017-03-19 16:09:46 +01001003 call assert_equal('', getbufvar(9999, ''))
1004 call assert_equal(def_num, getbufvar(9999, '', def_num))
Bram Moolenaar79518e22017-02-17 16:31:35 +01001005 unlet def_num
1006
Bram Moolenaar507647d2017-02-17 16:43:49 +01001007 call assert_equal(0, getbufvar(bnr, '&autoindent'))
1008 call assert_equal(0, getbufvar(bnr, '&autoindent', 1))
Bram Moolenaar79518e22017-02-17 16:31:35 +01001009
Bram Moolenaar8dfcce32020-03-18 19:32:26 +01001010 " Set and get a buffer-local variable
1011 call setbufvar(bnr, 'bufvar_test', ['one', 'two'])
1012 call assert_equal(['one', 'two'], getbufvar(bnr, 'bufvar_test'))
1013
Bram Moolenaar79518e22017-02-17 16:31:35 +01001014 " Open new window with forced option values
1015 set fileformats=unix,dos
1016 new ++ff=dos ++bin ++enc=iso-8859-2
1017 call assert_equal('dos', getbufvar(bufnr('%'), '&fileformat'))
1018 call assert_equal(1, getbufvar(bufnr('%'), '&bin'))
1019 call assert_equal('iso-8859-2', getbufvar(bufnr('%'), '&fenc'))
1020 close
1021
Bram Moolenaar52592752020-04-03 18:43:35 +02001022 " Get the b: dict.
1023 let b:testvar = 'one'
1024 new
1025 let b:testvar = 'two'
1026 let thebuf = bufnr()
1027 wincmd w
1028 call assert_equal('two', getbufvar(thebuf, 'testvar'))
1029 call assert_equal('two', getbufvar(thebuf, '').testvar)
1030 bwipe!
1031
Bram Moolenaar79518e22017-02-17 16:31:35 +01001032 set fileformats&
1033endfunc
Bram Moolenaarcaf64342017-03-02 22:11:33 +01001034
Bram Moolenaar41042f32017-03-09 12:09:32 +01001035func Test_last_buffer_nr()
1036 call assert_equal(bufnr('$'), last_buffer_nr())
1037endfunc
1038
1039func Test_stridx()
1040 call assert_equal(-1, stridx('', 'l'))
1041 call assert_equal(0, stridx('', ''))
Bram Moolenaarf6ed61e2019-09-07 19:05:09 +02001042 call assert_equal(0, 'hello'->stridx(''))
Bram Moolenaar41042f32017-03-09 12:09:32 +01001043 call assert_equal(-1, stridx('hello', 'L'))
1044 call assert_equal(2, stridx('hello', 'l', -1))
1045 call assert_equal(2, stridx('hello', 'l', 0))
Bram Moolenaarf6ed61e2019-09-07 19:05:09 +02001046 call assert_equal(2, 'hello'->stridx('l', 1))
Bram Moolenaar41042f32017-03-09 12:09:32 +01001047 call assert_equal(3, stridx('hello', 'l', 3))
1048 call assert_equal(-1, stridx('hello', 'l', 4))
1049 call assert_equal(-1, stridx('hello', 'l', 10))
1050 call assert_equal(2, stridx('hello', 'll'))
1051 call assert_equal(-1, stridx('hello', 'hello world'))
Bram Moolenaar0e05de42020-03-25 22:23:46 +01001052 call assert_fails("let n=stridx('hello', [])", 'E730:')
1053 call assert_fails("let n=stridx([], 'l')", 'E730:')
Bram Moolenaar41042f32017-03-09 12:09:32 +01001054endfunc
1055
1056func Test_strridx()
1057 call assert_equal(-1, strridx('', 'l'))
1058 call assert_equal(0, strridx('', ''))
1059 call assert_equal(5, strridx('hello', ''))
1060 call assert_equal(-1, strridx('hello', 'L'))
Bram Moolenaarf6ed61e2019-09-07 19:05:09 +02001061 call assert_equal(3, 'hello'->strridx('l'))
Bram Moolenaar41042f32017-03-09 12:09:32 +01001062 call assert_equal(3, strridx('hello', 'l', 10))
1063 call assert_equal(3, strridx('hello', 'l', 3))
1064 call assert_equal(2, strridx('hello', 'l', 2))
1065 call assert_equal(-1, strridx('hello', 'l', 1))
1066 call assert_equal(-1, strridx('hello', 'l', 0))
1067 call assert_equal(-1, strridx('hello', 'l', -1))
1068 call assert_equal(2, strridx('hello', 'll'))
1069 call assert_equal(-1, strridx('hello', 'hello world'))
Bram Moolenaar0e05de42020-03-25 22:23:46 +01001070 call assert_fails("let n=strridx('hello', [])", 'E730:')
1071 call assert_fails("let n=strridx([], 'l')", 'E730:')
Bram Moolenaar41042f32017-03-09 12:09:32 +01001072endfunc
1073
Bram Moolenaar1190cf62017-09-14 14:31:18 +02001074func Test_match_func()
1075 call assert_equal(4, match('testing', 'ing'))
Bram Moolenaara1449832019-09-01 20:16:52 +02001076 call assert_equal(4, 'testing'->match('ing', 2))
Bram Moolenaar1190cf62017-09-14 14:31:18 +02001077 call assert_equal(-1, match('testing', 'ing', 5))
1078 call assert_equal(-1, match('testing', 'ing', 8))
1079 call assert_equal(1, match(['vim', 'testing', 'execute'], 'ing'))
1080 call assert_equal(-1, match(['vim', 'testing', 'execute'], 'img'))
Bram Moolenaar0e05de42020-03-25 22:23:46 +01001081 call assert_fails("let x=match('vim', [])", 'E730:')
1082 call assert_equal(3, match(['a', 'b', 'c', 'a'], 'a', 1))
1083 call assert_equal(-1, match(['a', 'b', 'c', 'a'], 'a', 5))
1084 call assert_equal(4, match('testing', 'ing', -1))
1085 call assert_fails("let x=match('testing', 'ing', 0, [])", 'E745:')
Bram Moolenaarad48e6c2020-04-21 22:19:45 +02001086 call assert_equal(-1, match(test_null_list(), 2))
Bram Moolenaar531be472020-09-23 22:38:05 +02001087 call assert_equal(-1, match('abc', '\\%('))
Bram Moolenaar1190cf62017-09-14 14:31:18 +02001088endfunc
1089
Bram Moolenaar41042f32017-03-09 12:09:32 +01001090func Test_matchend()
1091 call assert_equal(7, matchend('testing', 'ing'))
Bram Moolenaara1449832019-09-01 20:16:52 +02001092 call assert_equal(7, 'testing'->matchend('ing', 2))
Bram Moolenaar41042f32017-03-09 12:09:32 +01001093 call assert_equal(-1, matchend('testing', 'ing', 5))
Bram Moolenaar1190cf62017-09-14 14:31:18 +02001094 call assert_equal(-1, matchend('testing', 'ing', 8))
1095 call assert_equal(match(['vim', 'testing', 'execute'], 'ing'), matchend(['vim', 'testing', 'execute'], 'ing'))
1096 call assert_equal(match(['vim', 'testing', 'execute'], 'img'), matchend(['vim', 'testing', 'execute'], 'img'))
1097endfunc
1098
1099func Test_matchlist()
1100 call assert_equal(['acd', 'a', '', 'c', 'd', '', '', '', '', ''], matchlist('acd', '\(a\)\?\(b\)\?\(c\)\?\(.*\)'))
Bram Moolenaara1449832019-09-01 20:16:52 +02001101 call assert_equal(['d', '', '', '', 'd', '', '', '', '', ''], 'acd'->matchlist('\(a\)\?\(b\)\?\(c\)\?\(.*\)', 2))
Bram Moolenaar1190cf62017-09-14 14:31:18 +02001102 call assert_equal([], matchlist('acd', '\(a\)\?\(b\)\?\(c\)\?\(.*\)', 4))
1103endfunc
1104
1105func Test_matchstr()
1106 call assert_equal('ing', matchstr('testing', 'ing'))
Bram Moolenaara1449832019-09-01 20:16:52 +02001107 call assert_equal('ing', 'testing'->matchstr('ing', 2))
Bram Moolenaar1190cf62017-09-14 14:31:18 +02001108 call assert_equal('', matchstr('testing', 'ing', 5))
1109 call assert_equal('', matchstr('testing', 'ing', 8))
1110 call assert_equal('testing', matchstr(['vim', 'testing', 'execute'], 'ing'))
1111 call assert_equal('', matchstr(['vim', 'testing', 'execute'], 'img'))
1112endfunc
1113
1114func Test_matchstrpos()
1115 call assert_equal(['ing', 4, 7], matchstrpos('testing', 'ing'))
Bram Moolenaara1449832019-09-01 20:16:52 +02001116 call assert_equal(['ing', 4, 7], 'testing'->matchstrpos('ing', 2))
Bram Moolenaar1190cf62017-09-14 14:31:18 +02001117 call assert_equal(['', -1, -1], matchstrpos('testing', 'ing', 5))
1118 call assert_equal(['', -1, -1], matchstrpos('testing', 'ing', 8))
1119 call assert_equal(['ing', 1, 4, 7], matchstrpos(['vim', 'testing', 'execute'], 'ing'))
1120 call assert_equal(['', -1, -1, -1], matchstrpos(['vim', 'testing', 'execute'], 'img'))
Bram Moolenaar92b83cc2020-04-25 15:24:44 +02001121 call assert_equal(['', -1, -1], matchstrpos(test_null_list(), '\a'))
Bram Moolenaar41042f32017-03-09 12:09:32 +01001122endfunc
1123
1124func Test_nextnonblank_prevnonblank()
1125 new
1126insert
1127This
1128
1129
1130is
1131
1132a
1133Test
1134.
1135 call assert_equal(0, nextnonblank(-1))
1136 call assert_equal(0, nextnonblank(0))
1137 call assert_equal(1, nextnonblank(1))
Bram Moolenaar3f4f3d82019-09-04 20:05:59 +02001138 call assert_equal(4, 2->nextnonblank())
Bram Moolenaar41042f32017-03-09 12:09:32 +01001139 call assert_equal(4, nextnonblank(3))
1140 call assert_equal(4, nextnonblank(4))
1141 call assert_equal(6, nextnonblank(5))
1142 call assert_equal(6, nextnonblank(6))
1143 call assert_equal(7, nextnonblank(7))
Bram Moolenaar3f4f3d82019-09-04 20:05:59 +02001144 call assert_equal(0, 8->nextnonblank())
Bram Moolenaar41042f32017-03-09 12:09:32 +01001145
1146 call assert_equal(0, prevnonblank(-1))
1147 call assert_equal(0, prevnonblank(0))
Bram Moolenaar3f4f3d82019-09-04 20:05:59 +02001148 call assert_equal(1, 1->prevnonblank())
Bram Moolenaar41042f32017-03-09 12:09:32 +01001149 call assert_equal(1, prevnonblank(2))
1150 call assert_equal(1, prevnonblank(3))
1151 call assert_equal(4, prevnonblank(4))
Bram Moolenaar3f4f3d82019-09-04 20:05:59 +02001152 call assert_equal(4, 5->prevnonblank())
Bram Moolenaar41042f32017-03-09 12:09:32 +01001153 call assert_equal(6, prevnonblank(6))
1154 call assert_equal(7, prevnonblank(7))
1155 call assert_equal(0, prevnonblank(8))
1156 bw!
1157endfunc
1158
1159func Test_byte2line_line2byte()
1160 new
Bram Moolenaarc26f7c62018-08-20 22:53:04 +02001161 set endofline
Bram Moolenaar41042f32017-03-09 12:09:32 +01001162 call setline(1, ['a', 'bc', 'd'])
1163
1164 set fileformat=unix
1165 call assert_equal([-1, -1, 1, 1, 2, 2, 2, 3, 3, -1],
1166 \ map(range(-1, 8), 'byte2line(v:val)'))
1167 call assert_equal([-1, -1, 1, 3, 6, 8, -1],
1168 \ map(range(-1, 5), 'line2byte(v:val)'))
1169
1170 set fileformat=mac
1171 call assert_equal([-1, -1, 1, 1, 2, 2, 2, 3, 3, -1],
Bram Moolenaar64b4d732019-08-22 22:18:17 +02001172 \ map(range(-1, 8), 'v:val->byte2line()'))
Bram Moolenaar41042f32017-03-09 12:09:32 +01001173 call assert_equal([-1, -1, 1, 3, 6, 8, -1],
Bram Moolenaar02b31112019-08-31 22:16:38 +02001174 \ map(range(-1, 5), 'v:val->line2byte()'))
Bram Moolenaar41042f32017-03-09 12:09:32 +01001175
1176 set fileformat=dos
1177 call assert_equal([-1, -1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, -1],
1178 \ map(range(-1, 11), 'byte2line(v:val)'))
1179 call assert_equal([-1, -1, 1, 4, 8, 11, -1],
1180 \ map(range(-1, 5), 'line2byte(v:val)'))
1181
Bram Moolenaarc26f7c62018-08-20 22:53:04 +02001182 bw!
1183 set noendofline nofixendofline
1184 normal a-
1185 for ff in ["unix", "mac", "dos"]
1186 let &fileformat = ff
1187 call assert_equal(1, line2byte(1))
1188 call assert_equal(2, line2byte(2)) " line2byte(line("$") + 1) is the buffer size plus one (as per :help line2byte).
1189 endfor
1190
1191 set endofline& fixendofline& fileformat&
Bram Moolenaar41042f32017-03-09 12:09:32 +01001192 bw!
1193endfunc
1194
Christian Brabandt67672ef2023-04-24 21:09:54 +01001195" Test for byteidx() using a character index
Bram Moolenaar64b4d732019-08-22 22:18:17 +02001196func Test_byteidx()
1197 let a = '.é.' " one char of two bytes
1198 call assert_equal(0, byteidx(a, 0))
Bram Moolenaar64b4d732019-08-22 22:18:17 +02001199 call assert_equal(1, byteidx(a, 1))
Bram Moolenaar64b4d732019-08-22 22:18:17 +02001200 call assert_equal(3, byteidx(a, 2))
Bram Moolenaar64b4d732019-08-22 22:18:17 +02001201 call assert_equal(4, byteidx(a, 3))
Bram Moolenaar64b4d732019-08-22 22:18:17 +02001202 call assert_equal(-1, byteidx(a, 4))
Bram Moolenaar64b4d732019-08-22 22:18:17 +02001203
1204 let b = '.é.' " normal e with composing char
1205 call assert_equal(0, b->byteidx(0))
1206 call assert_equal(1, b->byteidx(1))
1207 call assert_equal(4, b->byteidx(2))
1208 call assert_equal(5, b->byteidx(3))
1209 call assert_equal(-1, b->byteidx(4))
1210
Christian Brabandt67672ef2023-04-24 21:09:54 +01001211 " string with multiple composing characters
1212 let str = '-ą́-ą́'
1213 call assert_equal(0, byteidx(str, 0))
1214 call assert_equal(1, byteidx(str, 1))
1215 call assert_equal(6, byteidx(str, 2))
1216 call assert_equal(7, byteidx(str, 3))
1217 call assert_equal(12, byteidx(str, 4))
1218 call assert_equal(-1, byteidx(str, 5))
1219
1220 " empty string
1221 call assert_equal(0, byteidx('', 0))
1222 call assert_equal(-1, byteidx('', 1))
1223
1224 " error cases
1225 call assert_fails("call byteidx([], 0)", 'E730:')
1226 call assert_fails("call byteidx('abc', [])", 'E745:')
1227endfunc
1228
1229" Test for byteidxcomp() using a character index
1230func Test_byteidxcomp()
1231 let a = '.é.' " one char of two bytes
1232 call assert_equal(0, byteidxcomp(a, 0))
1233 call assert_equal(1, byteidxcomp(a, 1))
1234 call assert_equal(3, byteidxcomp(a, 2))
1235 call assert_equal(4, byteidxcomp(a, 3))
1236 call assert_equal(-1, byteidxcomp(a, 4))
1237
1238 let b = '.é.' " normal e with composing char
Bram Moolenaar64b4d732019-08-22 22:18:17 +02001239 call assert_equal(0, b->byteidxcomp(0))
1240 call assert_equal(1, b->byteidxcomp(1))
1241 call assert_equal(2, b->byteidxcomp(2))
1242 call assert_equal(4, b->byteidxcomp(3))
1243 call assert_equal(5, b->byteidxcomp(4))
1244 call assert_equal(-1, b->byteidxcomp(5))
Christian Brabandt67672ef2023-04-24 21:09:54 +01001245
1246 " string with multiple composing characters
1247 let str = '-ą́-ą́'
1248 call assert_equal(0, byteidxcomp(str, 0))
1249 call assert_equal(1, byteidxcomp(str, 1))
1250 call assert_equal(2, byteidxcomp(str, 2))
1251 call assert_equal(4, byteidxcomp(str, 3))
1252 call assert_equal(6, byteidxcomp(str, 4))
1253 call assert_equal(7, byteidxcomp(str, 5))
1254 call assert_equal(8, byteidxcomp(str, 6))
1255 call assert_equal(10, byteidxcomp(str, 7))
1256 call assert_equal(12, byteidxcomp(str, 8))
1257 call assert_equal(-1, byteidxcomp(str, 9))
1258
1259 " empty string
1260 call assert_equal(0, byteidxcomp('', 0))
1261 call assert_equal(-1, byteidxcomp('', 1))
1262
1263 " error cases
Bram Moolenaar0e05de42020-03-25 22:23:46 +01001264 call assert_fails("call byteidxcomp([], 0)", 'E730:')
Christian Brabandt67672ef2023-04-24 21:09:54 +01001265 call assert_fails("call byteidxcomp('abc', [])", 'E745:')
Bram Moolenaar64b4d732019-08-22 22:18:17 +02001266endfunc
1267
Christian Brabandt67672ef2023-04-24 21:09:54 +01001268" Test for byteidx() using a UTF-16 index
1269func Test_byteidx_from_utf16_index()
1270 " string with single byte characters
1271 let str = "abc"
1272 for i in range(3)
1273 call assert_equal(i, byteidx(str, i, v:true))
1274 endfor
1275 call assert_equal(3, byteidx(str, 3, v:true))
1276 call assert_equal(-1, byteidx(str, 4, v:true))
1277
1278 " string with two byte characters
1279 let str = "a©©b"
1280 call assert_equal(0, byteidx(str, 0, v:true))
1281 call assert_equal(1, byteidx(str, 1, v:true))
1282 call assert_equal(3, byteidx(str, 2, v:true))
1283 call assert_equal(5, byteidx(str, 3, v:true))
1284 call assert_equal(6, byteidx(str, 4, v:true))
1285 call assert_equal(-1, byteidx(str, 5, v:true))
1286
1287 " string with two byte characters
1288 let str = "a😊😊b"
1289 call assert_equal(0, byteidx(str, 0, v:true))
1290 call assert_equal(1, byteidx(str, 1, v:true))
1291 call assert_equal(1, byteidx(str, 2, v:true))
1292 call assert_equal(5, byteidx(str, 3, v:true))
1293 call assert_equal(5, byteidx(str, 4, v:true))
1294 call assert_equal(9, byteidx(str, 5, v:true))
1295 call assert_equal(10, byteidx(str, 6, v:true))
1296 call assert_equal(-1, byteidx(str, 7, v:true))
1297
1298 " string with composing characters
1299 let str = '-á-b́'
1300 call assert_equal(0, byteidx(str, 0, v:true))
1301 call assert_equal(1, byteidx(str, 1, v:true))
1302 call assert_equal(4, byteidx(str, 2, v:true))
1303 call assert_equal(5, byteidx(str, 3, v:true))
1304 call assert_equal(8, byteidx(str, 4, v:true))
1305 call assert_equal(-1, byteidx(str, 5, v:true))
1306
1307 " string with multiple composing characters
1308 let str = '-ą́-ą́'
1309 call assert_equal(0, byteidx(str, 0, v:true))
1310 call assert_equal(1, byteidx(str, 1, v:true))
1311 call assert_equal(6, byteidx(str, 2, v:true))
1312 call assert_equal(7, byteidx(str, 3, v:true))
1313 call assert_equal(12, byteidx(str, 4, v:true))
1314 call assert_equal(-1, byteidx(str, 5, v:true))
1315
1316 " empty string
1317 call assert_equal(0, byteidx('', 0, v:true))
1318 call assert_equal(-1, byteidx('', 1, v:true))
1319
1320 " error cases
1321 call assert_fails('call byteidx(str, 0, [])', 'E745:')
1322endfunc
1323
1324" Test for byteidxcomp() using a UTF-16 index
1325func Test_byteidxcomp_from_utf16_index()
1326 " string with single byte characters
1327 let str = "abc"
1328 for i in range(3)
1329 call assert_equal(i, byteidxcomp(str, i, v:true))
1330 endfor
1331 call assert_equal(3, byteidxcomp(str, 3, v:true))
1332 call assert_equal(-1, byteidxcomp(str, 4, v:true))
1333
1334 " string with two byte characters
1335 let str = "a©©b"
1336 call assert_equal(0, byteidxcomp(str, 0, v:true))
1337 call assert_equal(1, byteidxcomp(str, 1, v:true))
1338 call assert_equal(3, byteidxcomp(str, 2, v:true))
1339 call assert_equal(5, byteidxcomp(str, 3, v:true))
1340 call assert_equal(6, byteidxcomp(str, 4, v:true))
1341 call assert_equal(-1, byteidxcomp(str, 5, v:true))
1342
1343 " string with two byte characters
1344 let str = "a😊😊b"
1345 call assert_equal(0, byteidxcomp(str, 0, v:true))
1346 call assert_equal(1, byteidxcomp(str, 1, v:true))
1347 call assert_equal(1, byteidxcomp(str, 2, v:true))
1348 call assert_equal(5, byteidxcomp(str, 3, v:true))
1349 call assert_equal(5, byteidxcomp(str, 4, v:true))
1350 call assert_equal(9, byteidxcomp(str, 5, v:true))
1351 call assert_equal(10, byteidxcomp(str, 6, v:true))
1352 call assert_equal(-1, byteidxcomp(str, 7, v:true))
1353
1354 " string with composing characters
1355 let str = '-á-b́'
1356 call assert_equal(0, byteidxcomp(str, 0, v:true))
1357 call assert_equal(1, byteidxcomp(str, 1, v:true))
1358 call assert_equal(2, byteidxcomp(str, 2, v:true))
1359 call assert_equal(4, byteidxcomp(str, 3, v:true))
1360 call assert_equal(5, byteidxcomp(str, 4, v:true))
1361 call assert_equal(6, byteidxcomp(str, 5, v:true))
1362 call assert_equal(8, byteidxcomp(str, 6, v:true))
1363 call assert_equal(-1, byteidxcomp(str, 7, v:true))
1364 call assert_fails('call byteidxcomp(str, 0, [])', 'E745:')
1365
1366 " string with multiple composing characters
1367 let str = '-ą́-ą́'
1368 call assert_equal(0, byteidxcomp(str, 0, v:true))
1369 call assert_equal(1, byteidxcomp(str, 1, v:true))
1370 call assert_equal(2, byteidxcomp(str, 2, v:true))
1371 call assert_equal(4, byteidxcomp(str, 3, v:true))
1372 call assert_equal(6, byteidxcomp(str, 4, v:true))
1373 call assert_equal(7, byteidxcomp(str, 5, v:true))
1374 call assert_equal(8, byteidxcomp(str, 6, v:true))
1375 call assert_equal(10, byteidxcomp(str, 7, v:true))
1376 call assert_equal(12, byteidxcomp(str, 8, v:true))
1377 call assert_equal(-1, byteidxcomp(str, 9, v:true))
1378
1379 " empty string
1380 call assert_equal(0, byteidxcomp('', 0, v:true))
1381 call assert_equal(-1, byteidxcomp('', 1, v:true))
1382
1383 " error cases
1384 call assert_fails('call byteidxcomp(str, 0, [])', 'E745:')
1385endfunc
1386
1387" Test for charidx() using a byte index
Bram Moolenaar17793ef2020-12-28 12:56:58 +01001388func Test_charidx()
1389 let a = 'xáb́y'
1390 call assert_equal(0, charidx(a, 0))
1391 call assert_equal(1, charidx(a, 3))
1392 call assert_equal(2, charidx(a, 4))
1393 call assert_equal(3, charidx(a, 7))
1394 call assert_equal(-1, charidx(a, 8))
Dominique Pelle6d37e8e2021-05-06 17:36:55 +02001395 call assert_equal(-1, charidx(a, -1))
Bram Moolenaar17793ef2020-12-28 12:56:58 +01001396
1397 " count composing characters
Christian Brabandt67672ef2023-04-24 21:09:54 +01001398 call assert_equal(0, a->charidx(0, 1))
1399 call assert_equal(2, a->charidx(2, 1))
1400 call assert_equal(3, a->charidx(4, 1))
1401 call assert_equal(5, a->charidx(7, 1))
1402 call assert_equal(-1, a->charidx(8, 1))
1403
1404 " empty string
1405 call assert_equal(-1, charidx('', 0))
Bram Moolenaar17793ef2020-12-28 12:56:58 +01001406 call assert_equal(-1, charidx('', 0, 1))
1407
Christian Brabandt67672ef2023-04-24 21:09:54 +01001408 " error cases
1409 call assert_equal(-1, charidx(test_null_string(), 0))
Yegappan Lakshmanan8deb2b32022-09-02 15:15:27 +01001410 call assert_fails('let x = charidx([], 1)', 'E1174:')
1411 call assert_fails('let x = charidx("abc", [])', 'E1210:')
1412 call assert_fails('let x = charidx("abc", 1, [])', 'E1212:')
1413 call assert_fails('let x = charidx("abc", 1, -1)', 'E1212:')
1414 call assert_fails('let x = charidx("abc", 1, 2)', 'E1212:')
Bram Moolenaar17793ef2020-12-28 12:56:58 +01001415endfunc
1416
Christian Brabandt67672ef2023-04-24 21:09:54 +01001417" Test for charidx() using a UTF-16 index
1418func Test_charidx_from_utf16_index()
1419 " string with single byte characters
1420 let str = "abc"
1421 for i in range(3)
1422 call assert_equal(i, charidx(str, i, v:false, v:true))
1423 endfor
1424 call assert_equal(-1, charidx(str, 3, v:false, v:true))
1425
1426 " string with two byte characters
1427 let str = "a©©b"
1428 call assert_equal(0, charidx(str, 0, v:false, v:true))
1429 call assert_equal(1, charidx(str, 1, v:false, v:true))
1430 call assert_equal(2, charidx(str, 2, v:false, v:true))
1431 call assert_equal(3, charidx(str, 3, v:false, v:true))
1432 call assert_equal(-1, charidx(str, 4, v:false, v:true))
1433
1434 " string with four byte characters
1435 let str = "a😊😊b"
1436 call assert_equal(0, charidx(str, 0, v:false, v:true))
1437 call assert_equal(1, charidx(str, 1, v:false, v:true))
1438 call assert_equal(1, charidx(str, 2, v:false, v:true))
1439 call assert_equal(2, charidx(str, 3, v:false, v:true))
1440 call assert_equal(2, charidx(str, 4, v:false, v:true))
1441 call assert_equal(3, charidx(str, 5, v:false, v:true))
1442 call assert_equal(-1, charidx(str, 6, v:false, v:true))
1443
1444 " string with composing characters
1445 let str = '-á-b́'
1446 for i in str->strcharlen()->range()
1447 call assert_equal(i, charidx(str, i, v:false, v:true))
1448 endfor
1449 call assert_equal(-1, charidx(str, 4, v:false, v:true))
1450 for i in str->strchars()->range()
1451 call assert_equal(i, charidx(str, i, v:true, v:true))
1452 endfor
1453 call assert_equal(-1, charidx(str, 6, v:true, v:true))
1454
1455 " string with multiple composing characters
1456 let str = '-ą́-ą́'
1457 for i in str->strcharlen()->range()
1458 call assert_equal(i, charidx(str, i, v:false, v:true))
1459 endfor
1460 call assert_equal(-1, charidx(str, 4, v:false, v:true))
1461 for i in str->strchars()->range()
1462 call assert_equal(i, charidx(str, i, v:true, v:true))
1463 endfor
1464 call assert_equal(-1, charidx(str, 8, v:true, v:true))
1465
1466 " empty string
1467 call assert_equal(-1, charidx('', 0, v:false, v:true))
1468 call assert_equal(-1, charidx('', 0, v:true, v:true))
1469
1470 " error cases
1471 call assert_equal(-1, charidx('', 0, v:false, v:true))
1472 call assert_equal(-1, charidx('', 0, v:true, v:true))
1473 call assert_equal(-1, charidx(test_null_string(), 0, v:false, v:true))
1474 call assert_fails('let x = charidx("abc", 1, v:false, [])', 'E1212:')
1475 call assert_fails('let x = charidx("abc", 1, v:true, [])', 'E1212:')
1476endfunc
1477
1478" Test for utf16idx() using a byte index
1479func Test_utf16idx_from_byteidx()
1480 " UTF-16 index of a string with single byte characters
1481 let str = "abc"
1482 for i in range(3)
1483 call assert_equal(i, utf16idx(str, i))
1484 endfor
1485 call assert_equal(-1, utf16idx(str, 3))
1486
1487 " UTF-16 index of a string with two byte characters
1488 let str = 'a©©b'
1489 call assert_equal(0, str->utf16idx(0))
1490 call assert_equal(1, str->utf16idx(1))
1491 call assert_equal(1, str->utf16idx(2))
1492 call assert_equal(2, str->utf16idx(3))
1493 call assert_equal(2, str->utf16idx(4))
1494 call assert_equal(3, str->utf16idx(5))
1495 call assert_equal(-1, str->utf16idx(6))
1496
1497 " UTF-16 index of a string with four byte characters
1498 let str = 'a😊😊b'
1499 call assert_equal(0, utf16idx(str, 0))
1500 call assert_equal(2, utf16idx(str, 1))
1501 call assert_equal(2, utf16idx(str, 2))
1502 call assert_equal(2, utf16idx(str, 3))
1503 call assert_equal(2, utf16idx(str, 4))
1504 call assert_equal(4, utf16idx(str, 5))
1505 call assert_equal(4, utf16idx(str, 6))
1506 call assert_equal(4, utf16idx(str, 7))
1507 call assert_equal(4, utf16idx(str, 8))
1508 call assert_equal(5, utf16idx(str, 9))
1509 call assert_equal(-1, utf16idx(str, 10))
1510
1511 " UTF-16 index of a string with composing characters
1512 let str = '-á-b́'
1513 call assert_equal(0, utf16idx(str, 0))
1514 call assert_equal(1, utf16idx(str, 1))
1515 call assert_equal(1, utf16idx(str, 2))
1516 call assert_equal(1, utf16idx(str, 3))
1517 call assert_equal(2, utf16idx(str, 4))
1518 call assert_equal(3, utf16idx(str, 5))
1519 call assert_equal(3, utf16idx(str, 6))
1520 call assert_equal(3, utf16idx(str, 7))
1521 call assert_equal(-1, utf16idx(str, 8))
1522 call assert_equal(0, utf16idx(str, 0, v:true))
1523 call assert_equal(1, utf16idx(str, 1, v:true))
1524 call assert_equal(2, utf16idx(str, 2, v:true))
1525 call assert_equal(2, utf16idx(str, 3, v:true))
1526 call assert_equal(3, utf16idx(str, 4, v:true))
1527 call assert_equal(4, utf16idx(str, 5, v:true))
1528 call assert_equal(5, utf16idx(str, 6, v:true))
1529 call assert_equal(5, utf16idx(str, 7, v:true))
1530 call assert_equal(-1, utf16idx(str, 8, v:true))
1531
1532 " string with multiple composing characters
1533 let str = '-ą́-ą́'
1534 call assert_equal(0, utf16idx(str, 0))
1535 call assert_equal(1, utf16idx(str, 1))
1536 call assert_equal(1, utf16idx(str, 2))
1537 call assert_equal(1, utf16idx(str, 3))
1538 call assert_equal(1, utf16idx(str, 4))
1539 call assert_equal(1, utf16idx(str, 5))
1540 call assert_equal(2, utf16idx(str, 6))
1541 call assert_equal(3, utf16idx(str, 7))
1542 call assert_equal(3, utf16idx(str, 8))
1543 call assert_equal(3, utf16idx(str, 9))
1544 call assert_equal(3, utf16idx(str, 10))
1545 call assert_equal(3, utf16idx(str, 11))
1546 call assert_equal(-1, utf16idx(str, 12))
1547 call assert_equal(0, utf16idx(str, 0, v:true))
1548 call assert_equal(1, utf16idx(str, 1, v:true))
1549 call assert_equal(2, utf16idx(str, 2, v:true))
1550 call assert_equal(2, utf16idx(str, 3, v:true))
1551 call assert_equal(3, utf16idx(str, 4, v:true))
1552 call assert_equal(3, utf16idx(str, 5, v:true))
1553 call assert_equal(4, utf16idx(str, 6, v:true))
1554 call assert_equal(5, utf16idx(str, 7, v:true))
1555 call assert_equal(6, utf16idx(str, 8, v:true))
1556 call assert_equal(6, utf16idx(str, 9, v:true))
1557 call assert_equal(7, utf16idx(str, 10, v:true))
1558 call assert_equal(7, utf16idx(str, 11, v:true))
1559 call assert_equal(-1, utf16idx(str, 12, v:true))
1560
1561 " empty string
1562 call assert_equal(-1, utf16idx('', 0))
1563 call assert_equal(-1, utf16idx('', 0, v:true))
1564
1565 " error cases
1566 call assert_equal(-1, utf16idx("", 0))
1567 call assert_equal(-1, utf16idx("abc", -1))
1568 call assert_equal(-1, utf16idx(test_null_string(), 0))
1569 call assert_fails('let l = utf16idx([], 0)', 'E1174:')
1570 call assert_fails('let l = utf16idx("ab", [])', 'E1210:')
1571 call assert_fails('let l = utf16idx("ab", 0, [])', 'E1212:')
1572endfunc
1573
1574" Test for utf16idx() using a character index
1575func Test_utf16idx_from_charidx()
1576 let str = "abc"
1577 for i in str->strcharlen()->range()
1578 call assert_equal(i, utf16idx(str, i, v:false, v:true))
1579 endfor
1580 call assert_equal(-1, utf16idx(str, 3, v:false, v:true))
1581
1582 " UTF-16 index of a string with two byte characters
1583 let str = "a©©b"
1584 for i in str->strcharlen()->range()
1585 call assert_equal(i, utf16idx(str, i, v:false, v:true))
1586 endfor
1587 call assert_equal(-1, utf16idx(str, 4, v:false, v:true))
1588
1589 " UTF-16 index of a string with four byte characters
1590 let str = "a😊😊b"
1591 call assert_equal(0, utf16idx(str, 0, v:false, v:true))
1592 call assert_equal(2, utf16idx(str, 1, v:false, v:true))
1593 call assert_equal(4, utf16idx(str, 2, v:false, v:true))
1594 call assert_equal(5, utf16idx(str, 3, v:false, v:true))
1595 call assert_equal(-1, utf16idx(str, 4, v:false, v:true))
1596
1597 " UTF-16 index of a string with composing characters
1598 let str = '-á-b́'
1599 for i in str->strcharlen()->range()
1600 call assert_equal(i, utf16idx(str, i, v:false, v:true))
1601 endfor
1602 call assert_equal(-1, utf16idx(str, 4, v:false, v:true))
1603 for i in str->strchars()->range()
1604 call assert_equal(i, utf16idx(str, i, v:true, v:true))
1605 endfor
1606 call assert_equal(-1, utf16idx(str, 6, v:true, v:true))
1607
1608 " string with multiple composing characters
1609 let str = '-ą́-ą́'
1610 for i in str->strcharlen()->range()
1611 call assert_equal(i, utf16idx(str, i, v:false, v:true))
1612 endfor
1613 call assert_equal(-1, utf16idx(str, 4, v:false, v:true))
1614 for i in str->strchars()->range()
1615 call assert_equal(i, utf16idx(str, i, v:true, v:true))
1616 endfor
1617 call assert_equal(-1, utf16idx(str, 8, v:true, v:true))
1618
1619 " empty string
1620 call assert_equal(-1, utf16idx('', 0, v:false, v:true))
1621 call assert_equal(-1, utf16idx('', 0, v:true, v:true))
1622
1623 " error cases
1624 call assert_equal(-1, utf16idx(test_null_string(), 0, v:true, v:true))
1625 call assert_fails('let l = utf16idx("ab", 0, v:false, [])', 'E1212:')
1626endfunc
1627
1628" Test for strutf16len()
1629func Test_strutf16len()
1630 call assert_equal(3, strutf16len('abc'))
1631 call assert_equal(3, 'abc'->strutf16len(v:true))
1632 call assert_equal(4, strutf16len('a©©b'))
1633 call assert_equal(4, strutf16len('a©©b', v:true))
1634 call assert_equal(6, strutf16len('a😊😊b'))
1635 call assert_equal(6, strutf16len('a😊😊b', v:true))
1636 call assert_equal(4, strutf16len('-á-b́'))
1637 call assert_equal(6, strutf16len('-á-b́', v:true))
1638 call assert_equal(4, strutf16len('-ą́-ą́'))
1639 call assert_equal(8, strutf16len('-ą́-ą́', v:true))
1640 call assert_equal(0, strutf16len(''))
1641
1642 " error cases
1643 call assert_fails('let l = strutf16len([])', 'E1174:')
1644 call assert_fails('let l = strutf16len("a", [])', 'E1212:')
1645 call assert_equal(0, strutf16len(test_null_string()))
1646endfunc
1647
Bram Moolenaar41042f32017-03-09 12:09:32 +01001648func Test_count()
1649 let l = ['a', 'a', 'A', 'b']
1650 call assert_equal(2, count(l, 'a'))
1651 call assert_equal(1, count(l, 'A'))
1652 call assert_equal(1, count(l, 'b'))
1653 call assert_equal(0, count(l, 'B'))
1654
1655 call assert_equal(2, count(l, 'a', 0))
1656 call assert_equal(1, count(l, 'A', 0))
1657 call assert_equal(1, count(l, 'b', 0))
1658 call assert_equal(0, count(l, 'B', 0))
1659
1660 call assert_equal(3, count(l, 'a', 1))
1661 call assert_equal(3, count(l, 'A', 1))
1662 call assert_equal(1, count(l, 'b', 1))
1663 call assert_equal(1, count(l, 'B', 1))
1664 call assert_equal(0, count(l, 'c', 1))
1665
1666 call assert_equal(1, count(l, 'a', 0, 1))
1667 call assert_equal(2, count(l, 'a', 1, 1))
1668 call assert_fails('call count(l, "a", 0, 10)', 'E684:')
Bram Moolenaar17aca702019-05-16 22:24:55 +02001669 call assert_fails('call count(l, "a", [])', 'E745:')
Bram Moolenaar41042f32017-03-09 12:09:32 +01001670
1671 let d = {1: 'a', 2: 'a', 3: 'A', 4: 'b'}
1672 call assert_equal(2, count(d, 'a'))
1673 call assert_equal(1, count(d, 'A'))
1674 call assert_equal(1, count(d, 'b'))
1675 call assert_equal(0, count(d, 'B'))
1676
1677 call assert_equal(2, count(d, 'a', 0))
1678 call assert_equal(1, count(d, 'A', 0))
1679 call assert_equal(1, count(d, 'b', 0))
1680 call assert_equal(0, count(d, 'B', 0))
1681
1682 call assert_equal(3, count(d, 'a', 1))
1683 call assert_equal(3, count(d, 'A', 1))
1684 call assert_equal(1, count(d, 'b', 1))
1685 call assert_equal(1, count(d, 'B', 1))
1686 call assert_equal(0, count(d, 'c', 1))
1687
1688 call assert_fails('call count(d, "a", 0, 1)', 'E474:')
Bram Moolenaar9966b212017-07-28 16:46:57 +02001689
1690 call assert_equal(0, count("foo", "bar"))
1691 call assert_equal(1, count("foo", "oo"))
1692 call assert_equal(2, count("foo", "o"))
1693 call assert_equal(0, count("foo", "O"))
1694 call assert_equal(2, count("foo", "O", 1))
1695 call assert_equal(2, count("fooooo", "oo"))
Bram Moolenaar338e47f2017-12-19 11:55:26 +01001696 call assert_equal(0, count("foo", ""))
Bram Moolenaar17aca702019-05-16 22:24:55 +02001697
1698 call assert_fails('call count(0, 0)', 'E712:')
Bram Moolenaar41042f32017-03-09 12:09:32 +01001699endfunc
1700
1701func Test_changenr()
1702 new Xchangenr
1703 call assert_equal(0, changenr())
1704 norm ifoo
1705 call assert_equal(1, changenr())
1706 set undolevels=10
1707 norm Sbar
1708 call assert_equal(2, changenr())
1709 undo
1710 call assert_equal(1, changenr())
1711 redo
1712 call assert_equal(2, changenr())
1713 bw!
1714 set undolevels&
1715endfunc
1716
1717func Test_filewritable()
1718 new Xfilewritable
1719 write!
1720 call assert_equal(1, filewritable('Xfilewritable'))
1721
1722 call assert_notequal(0, setfperm('Xfilewritable', 'r--r-----'))
1723 call assert_equal(0, filewritable('Xfilewritable'))
1724
1725 call assert_notequal(0, setfperm('Xfilewritable', 'rw-r-----'))
Bram Moolenaara4208962019-08-24 20:50:19 +02001726 call assert_equal(1, 'Xfilewritable'->filewritable())
Bram Moolenaar41042f32017-03-09 12:09:32 +01001727
1728 call assert_equal(0, filewritable('doesnotexist'))
1729
Bram Moolenaar70e67252022-09-27 19:34:35 +01001730 call mkdir('Xwritedir', 'D')
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01001731 call assert_equal(2, filewritable('Xwritedir'))
Bram Moolenaar0ff5ded2020-05-07 18:43:44 +02001732
Bram Moolenaar41042f32017-03-09 12:09:32 +01001733 call delete('Xfilewritable')
1734 bw!
1735endfunc
1736
Bram Moolenaar82956662018-10-06 15:18:45 +02001737func Test_Executable()
1738 if has('win32')
1739 call assert_equal(1, executable('notepad'))
Bram Moolenaara4208962019-08-24 20:50:19 +02001740 call assert_equal(1, 'notepad.exe'->executable())
Bram Moolenaar82956662018-10-06 15:18:45 +02001741 call assert_equal(0, executable('notepad.exe.exe'))
1742 call assert_equal(0, executable('shell32.dll'))
1743 call assert_equal(0, executable('win.ini'))
Bram Moolenaar95da1362020-05-30 18:37:55 +02001744
1745 " get "notepad" path and remove the leading drive and sep. (ex. 'C:\')
1746 let notepadcmd = exepath('notepad.exe')
1747 let driveroot = notepadcmd[:2]
1748 let notepadcmd = notepadcmd[3:]
1749 new
1750 " check that the relative path works in /
1751 execute 'lcd' driveroot
1752 call assert_equal(1, executable(notepadcmd))
1753 call assert_equal(driveroot .. notepadcmd, notepadcmd->exepath())
1754 bwipe
1755
1756 " create "notepad.bat"
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01001757 call mkdir('Xnotedir')
1758 let notepadbat = fnamemodify('Xnotedir/notepad.bat', ':p')
Bram Moolenaar95da1362020-05-30 18:37:55 +02001759 call writefile([], notepadbat)
1760 new
1761 " check that the path and the pathext order is valid
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01001762 lcd Xnotedir
Bram Moolenaar95da1362020-05-30 18:37:55 +02001763 let [pathext, $PATHEXT] = [$PATHEXT, '.com;.exe;.bat;.cmd']
1764 call assert_equal(notepadbat, exepath('notepad'))
1765 let $PATHEXT = pathext
1766 bwipe
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01001767 eval 'Xnotedir'->delete('rf')
Bram Moolenaar82956662018-10-06 15:18:45 +02001768 elseif has('unix')
Bram Moolenaara4208962019-08-24 20:50:19 +02001769 call assert_equal(1, 'cat'->executable())
Bram Moolenaara05a0d32018-10-07 18:43:05 +02001770 call assert_equal(0, executable('nodogshere'))
Bram Moolenaard08b8c42019-07-24 14:59:45 +02001771
1772 " get "cat" path and remove the leading /
1773 let catcmd = exepath('cat')[1:]
1774 new
Bram Moolenaara4208962019-08-24 20:50:19 +02001775 " check that the relative path works in /
Bram Moolenaard08b8c42019-07-24 14:59:45 +02001776 lcd /
1777 call assert_equal(1, executable(catcmd))
Bram Moolenaara3870832021-01-01 14:20:44 +01001778 let result = catcmd->exepath()
1779 " when using chroot looking for sbin/cat can return bin/cat, that is OK
1780 if catcmd =~ '\<sbin\>' && result =~ '\<bin\>'
1781 call assert_equal('/' .. substitute(catcmd, '\<sbin\>', 'bin', ''), result)
1782 else
Bram Moolenaarbf634a02021-07-31 17:20:04 +02001783 " /bin/cat and /usr/bin/cat may be hard linked, we could get either
1784 let result = substitute(result, '/usr/bin/cat', '/bin/cat', '')
1785 let catcmd = substitute(catcmd, 'usr/bin/cat', 'bin/cat', '')
Bram Moolenaara3870832021-01-01 14:20:44 +01001786 call assert_equal('/' .. catcmd, result)
1787 endif
Bram Moolenaard08b8c42019-07-24 14:59:45 +02001788 bwipe
Bram Moolenaar6d91bcb2020-08-12 18:50:36 +02001789 else
1790 throw 'Skipped: does not work on this platform'
Bram Moolenaar82956662018-10-06 15:18:45 +02001791 endif
1792endfunc
1793
LemonBoy40fd7e62022-05-05 20:18:16 +01001794func Test_executable_windows_store_apps()
1795 CheckMSWindows
1796
1797 " Windows Store apps install some 'decoy' .exe that require some careful
1798 " handling as they behave similarly to symlinks.
1799 let app_dir = expand("$LOCALAPPDATA\\Microsoft\\WindowsApps")
1800 if !isdirectory(app_dir)
1801 return
1802 endif
1803
1804 let save_path = $PATH
1805 let $PATH = app_dir
1806 " Ensure executable() finds all the app .exes
1807 for entry in readdir(app_dir)
1808 if entry =~ '\.exe$'
1809 call assert_true(executable(entry))
1810 endif
1811 endfor
1812
1813 let $PATH = save_path
1814endfunc
1815
Bram Moolenaar86621892019-03-30 21:51:28 +01001816func Test_executable_longname()
Bram Moolenaar6d91bcb2020-08-12 18:50:36 +02001817 CheckMSWindows
Bram Moolenaar86621892019-03-30 21:51:28 +01001818
Bram Moolenaarf637bce2020-11-23 18:14:56 +01001819 " Create a temporary .bat file with 205 characters in the name.
1820 " Maximum length of a filename (including the path) on MS-Windows is 259
1821 " characters.
1822 " See https://docs.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation
1823 let len = 259 - getcwd()->len() - 6
1824 if len > 200
1825 let len = 200
1826 endif
1827
1828 let fname = 'X' . repeat('あ', len) . '.bat'
Bram Moolenaar86621892019-03-30 21:51:28 +01001829 call writefile([], fname)
1830 call assert_equal(1, executable(fname))
1831 call delete(fname)
1832endfunc
1833
Bram Moolenaar41042f32017-03-09 12:09:32 +01001834func Test_hostname()
1835 let hostname_vim = hostname()
1836 if has('unix')
1837 let hostname_system = systemlist('uname -n')[0]
1838 call assert_equal(hostname_vim, hostname_system)
1839 endif
1840endfunc
1841
1842func Test_getpid()
1843 " getpid() always returns the same value within a vim instance.
1844 call assert_equal(getpid(), getpid())
1845 if has('unix')
1846 call assert_equal(systemlist('echo $PPID')[0], string(getpid()))
1847 endif
1848endfunc
1849
1850func Test_hlexists()
1851 call assert_equal(0, hlexists('does_not_exist'))
Bram Moolenaarf9f24ce2019-08-31 21:17:39 +02001852 call assert_equal(0, 'Number'->hlexists())
Bram Moolenaar41042f32017-03-09 12:09:32 +01001853 call assert_equal(0, highlight_exists('does_not_exist'))
1854 call assert_equal(0, highlight_exists('Number'))
1855 syntax on
1856 call assert_equal(0, hlexists('does_not_exist'))
1857 call assert_equal(1, hlexists('Number'))
1858 call assert_equal(0, highlight_exists('does_not_exist'))
1859 call assert_equal(1, highlight_exists('Number'))
1860 syntax off
1861endfunc
1862
Bram Moolenaar92b83cc2020-04-25 15:24:44 +02001863" Test for the col() function
Bram Moolenaar41042f32017-03-09 12:09:32 +01001864func Test_col()
1865 new
1866 call setline(1, 'abcdef')
1867 norm gg4|mx6|mY2|
1868 call assert_equal(2, col('.'))
1869 call assert_equal(7, col('$'))
Bram Moolenaar8b633132020-03-20 18:20:51 +01001870 call assert_equal(2, col('v'))
Bram Moolenaar41042f32017-03-09 12:09:32 +01001871 call assert_equal(4, col("'x"))
1872 call assert_equal(6, col("'Y"))
Bram Moolenaar1a3a8912019-08-23 22:31:37 +02001873 call assert_equal(2, [1, 2]->col())
Bram Moolenaar41042f32017-03-09 12:09:32 +01001874 call assert_equal(7, col([1, '$']))
1875
1876 call assert_equal(0, col(''))
1877 call assert_equal(0, col('x'))
1878 call assert_equal(0, col([2, '$']))
1879 call assert_equal(0, col([1, 100]))
1880 call assert_equal(0, col([1]))
Bram Moolenaar9d8d0b52020-04-24 22:47:31 +02001881 call assert_equal(0, col(test_null_list()))
Yegappan Lakshmanan4c8d2f02022-11-12 16:07:47 +00001882 call assert_fails('let c = col({})', 'E1222:')
1883 call assert_fails('let c = col(".", [])', 'E1210:')
Bram Moolenaar8b633132020-03-20 18:20:51 +01001884
1885 " test for getting the visual start column
1886 func T()
1887 let g:Vcol = col('v')
1888 return ''
1889 endfunc
1890 let g:Vcol = 0
1891 xmap <expr> <F2> T()
1892 exe "normal gg3|ve\<F2>"
1893 call assert_equal(3, g:Vcol)
1894 xunmap <F2>
1895 delfunc T
1896
Bram Moolenaar0e05de42020-03-25 22:23:46 +01001897 " Test for the visual line start and end marks '< and '>
1898 call setline(1, ['one', 'one two', 'one two three'])
1899 "normal! ggVG
1900 call feedkeys("ggVG\<Esc>", 'xt')
1901 call assert_equal(1, col("'<"))
1902 call assert_equal(14, col("'>"))
1903 " Delete the last line of the visually selected region
1904 $d
1905 call assert_notequal(14, col("'>"))
1906
1907 " Test with 'virtualedit'
1908 set virtualedit=all
1909 call cursor(1, 10)
1910 call assert_equal(4, col('.'))
1911 set virtualedit&
1912
Yegappan Lakshmanan4c8d2f02022-11-12 16:07:47 +00001913 " Test for getting the column number in another window
1914 let winid = win_getid()
1915 new
1916 call win_execute(winid, 'normal 1G$')
1917 call assert_equal(3, col('.', winid))
1918 call win_execute(winid, 'normal 2G')
1919 call assert_equal(8, col('$', winid))
1920 call assert_equal(0, col('.', 5001))
1921
Bram Moolenaar41042f32017-03-09 12:09:32 +01001922 bw!
1923endfunc
1924
Bram Moolenaar8d588cc2020-02-25 21:47:45 +01001925" Test for input()
1926func Test_input_func()
1927 " Test for prompt with multiple lines
1928 redir => v
1929 call feedkeys(":let c = input(\"A\\nB\\nC\\n? \")\<CR>B\<CR>", 'xt')
1930 redir END
1931 call assert_equal("B", c)
1932 call assert_equal(['A', 'B', 'C'], split(v, "\n"))
1933
1934 " Test for default value
1935 call feedkeys(":let c = input('color? ', 'red')\<CR>\<CR>", 'xt')
1936 call assert_equal('red', c)
1937
1938 " Test for completion at the input prompt
1939 func! Tcomplete(arglead, cmdline, pos)
1940 return "item1\nitem2\nitem3"
1941 endfunc
Bram Moolenaar9d489562020-07-30 20:08:50 +02001942 call feedkeys(":let c = input('Q? ', '', 'custom,Tcomplete')\<CR>"
Bram Moolenaar8d588cc2020-02-25 21:47:45 +01001943 \ .. "\<C-A>\<CR>", 'xt')
1944 delfunc Tcomplete
1945 call assert_equal('item1 item2 item3', c)
Bram Moolenaar578fe942020-02-27 21:32:51 +01001946
Bram Moolenaarf4fcedc2021-03-15 18:36:20 +01001947 " Test for using special characters as default input
Bram Moolenaar1f448d92021-03-22 19:37:06 +01001948 call feedkeys(":let c = input('name? ', \"x\\<BS>y\")\<CR>\<CR>", 'xt')
Bram Moolenaarf4fcedc2021-03-15 18:36:20 +01001949 call assert_equal('y', c)
1950
zeertzjqe3a529b2022-06-05 19:01:37 +01001951 " Test for using text with composing characters as default input
1952 call feedkeys(":let c = input('name? ', \"ã̳\")\<CR>\<CR>", 'xt')
1953 call assert_equal('ã̳', c)
1954
Bram Moolenaarf4fcedc2021-03-15 18:36:20 +01001955 " Test for using <CR> as default input
1956 call feedkeys(":let c = input('name? ', \"\\<CR>\")\<CR>x\<CR>", 'xt')
1957 call assert_equal(' x', c)
1958
Bram Moolenaar578fe942020-02-27 21:32:51 +01001959 call assert_fails("call input('F:', '', 'invalid')", 'E180:')
1960 call assert_fails("call input('F:', '', [])", 'E730:')
1961endfunc
1962
1963" Test for the inputdialog() function
1964func Test_inputdialog()
Bram Moolenaarfdcbe3c2020-06-15 21:41:56 +02001965 set timeout timeoutlen=10
Bram Moolenaar99fa7212020-04-26 15:59:55 +02001966 if has('gui_running')
1967 call assert_fails('let v=inputdialog([], "xx")', 'E730:')
1968 call assert_fails('let v=inputdialog("Q", [])', 'E730:')
1969 else
1970 call feedkeys(":let v=inputdialog('Q:', 'xx', 'yy')\<CR>\<CR>", 'xt')
1971 call assert_equal('xx', v)
1972 call feedkeys(":let v=inputdialog('Q:', 'xx', 'yy')\<CR>\<Esc>", 'xt')
1973 call assert_equal('yy', v)
1974 endif
Bram Moolenaarfdcbe3c2020-06-15 21:41:56 +02001975 set timeout& timeoutlen&
Bram Moolenaar8d588cc2020-02-25 21:47:45 +01001976endfunc
1977
1978" Test for inputlist()
Bram Moolenaar947b39e2018-07-22 19:36:37 +02001979func Test_inputlist()
1980 call feedkeys(":let c = inputlist(['Select color:', '1. red', '2. green', '3. blue'])\<cr>1\<cr>", 'tx')
1981 call assert_equal(1, c)
Bram Moolenaarf9f24ce2019-08-31 21:17:39 +02001982 call feedkeys(":let c = ['Select color:', '1. red', '2. green', '3. blue']->inputlist()\<cr>2\<cr>", 'tx')
Bram Moolenaar947b39e2018-07-22 19:36:37 +02001983 call assert_equal(2, c)
1984 call feedkeys(":let c = inputlist(['Select color:', '1. red', '2. green', '3. blue'])\<cr>3\<cr>", 'tx')
1985 call assert_equal(3, c)
1986
Bram Moolenaareebd5552020-06-10 15:45:57 +02001987 " CR to cancel
1988 call feedkeys(":let c = inputlist(['Select color:', '1. red', '2. green', '3. blue'])\<cr>\<cr>", 'tx')
1989 call assert_equal(0, c)
1990
1991 " Esc to cancel
1992 call feedkeys(":let c = inputlist(['Select color:', '1. red', '2. green', '3. blue'])\<cr>\<Esc>", 'tx')
1993 call assert_equal(0, c)
1994
1995 " q to cancel
1996 call feedkeys(":let c = inputlist(['Select color:', '1. red', '2. green', '3. blue'])\<cr>q", 'tx')
1997 call assert_equal(0, c)
1998
=?UTF-8?q?Luka=20Marku=C5=A1i=C4=87?=5cf94572021-05-20 21:14:20 +02001999 " Cancel after inputting a number
2000 call feedkeys(":let c = inputlist(['Select color:', '1. red', '2. green', '3. blue'])\<cr>5q", 'tx')
2001 call assert_equal(0, c)
2002
Bram Moolenaarcde0ff32020-04-04 14:00:39 +02002003 " Use backspace to delete characters in the prompt
2004 call feedkeys(":let c = inputlist(['Select color:', '1. red', '2. green', '3. blue'])\<cr>1\<BS>3\<BS>2\<cr>", 'tx')
2005 call assert_equal(2, c)
2006
2007 " Use mouse to make a selection
2008 call test_setmouse(&lines - 3, 2)
2009 call feedkeys(":let c = inputlist(['Select color:', '1. red', '2. green', '3. blue'])\<cr>\<LeftMouse>", 'tx')
2010 call assert_equal(1, c)
2011 " Mouse click outside of the list
2012 call test_setmouse(&lines - 6, 2)
2013 call feedkeys(":let c = inputlist(['Select color:', '1. red', '2. green', '3. blue'])\<cr>\<LeftMouse>", 'tx')
2014 call assert_equal(-2, c)
2015
Bram Moolenaar947b39e2018-07-22 19:36:37 +02002016 call assert_fails('call inputlist("")', 'E686:')
Bram Moolenaar92b83cc2020-04-25 15:24:44 +02002017 call assert_fails('call inputlist(test_null_list())', 'E686:')
Bram Moolenaar947b39e2018-07-22 19:36:37 +02002018endfunc
2019
Bram Moolenaar7bdcba02023-01-02 11:59:26 +00002020func Test_range_inputlist()
2021 " flush out any garbage left in the buffer
2022 while getchar(0)
2023 endwhile
2024
2025 call feedkeys(":let result = inputlist(range(10))\<CR>1\<CR>", 'x')
2026 call assert_equal(1, result)
2027 call feedkeys(":let result = inputlist(range(3, 10))\<CR>1\<CR>", 'x')
2028 call assert_equal(1, result)
2029
2030 unlet result
2031endfunc
2032
Bram Moolenaarcaf64342017-03-02 22:11:33 +01002033func Test_balloon_show()
Bram Moolenaar6d91bcb2020-08-12 18:50:36 +02002034 CheckFeature balloon_eval
Bram Moolenaarb47bed22021-04-14 17:06:43 +02002035
Bram Moolenaar6d91bcb2020-08-12 18:50:36 +02002036 " This won't do anything but must not crash either.
2037 call balloon_show('hi!')
2038 if !has('gui_running')
2039 call balloon_show(range(3))
2040 call balloon_show([])
Bram Moolenaara0107bd2017-03-02 22:48:01 +01002041 endif
Bram Moolenaarcaf64342017-03-02 22:11:33 +01002042endfunc
Bram Moolenaar2c90d512017-03-18 22:35:30 +01002043
2044func Test_setbufvar_options()
2045 " This tests that aucmd_prepbuf() and aucmd_restbuf() properly restore the
zeertzjq49f05242023-02-04 10:58:34 +00002046 " window layout and cursor position.
Bram Moolenaar2c90d512017-03-18 22:35:30 +01002047 call assert_equal(1, winnr('$'))
2048 split dummy_preview
2049 resize 2
2050 set winfixheight winfixwidth
2051 let prev_id = win_getid()
2052
2053 wincmd j
Bram Moolenaarc05d1c02020-09-04 18:38:06 +02002054 let wh = winheight(0)
Bram Moolenaar2c90d512017-03-18 22:35:30 +01002055 let dummy_buf = bufnr('dummy_buf1', v:true)
2056 call setbufvar(dummy_buf, '&buftype', 'nofile')
2057 execute 'belowright vertical split #' . dummy_buf
Bram Moolenaarc05d1c02020-09-04 18:38:06 +02002058 call assert_equal(wh, winheight(0))
Bram Moolenaar2c90d512017-03-18 22:35:30 +01002059 let dum1_id = win_getid()
zeertzjq49f05242023-02-04 10:58:34 +00002060 call setline(1, 'foo')
2061 normal! V$
2062 call assert_equal(4, col('.'))
2063 call setbufvar('dummy_preview', '&buftype', 'nofile')
2064 call assert_equal(4, col('.'))
Bram Moolenaar2c90d512017-03-18 22:35:30 +01002065
2066 wincmd h
Bram Moolenaarc05d1c02020-09-04 18:38:06 +02002067 let wh = winheight(0)
zeertzjq49f05242023-02-04 10:58:34 +00002068 call setline(1, 'foo')
2069 normal! V$
2070 call assert_equal(4, col('.'))
Bram Moolenaar2c90d512017-03-18 22:35:30 +01002071 let dummy_buf = bufnr('dummy_buf2', v:true)
Bram Moolenaar196b4662019-09-06 21:34:30 +02002072 eval 'nofile'->setbufvar(dummy_buf, '&buftype')
zeertzjq49f05242023-02-04 10:58:34 +00002073 call assert_equal(4, col('.'))
Bram Moolenaar2c90d512017-03-18 22:35:30 +01002074 execute 'belowright vertical split #' . dummy_buf
Bram Moolenaarc05d1c02020-09-04 18:38:06 +02002075 call assert_equal(wh, winheight(0))
Bram Moolenaar2c90d512017-03-18 22:35:30 +01002076
2077 bwipe!
2078 call win_gotoid(prev_id)
2079 bwipe!
2080 call win_gotoid(dum1_id)
2081 bwipe!
2082endfunc
Bram Moolenaard4863aa2017-04-07 19:50:12 +02002083
Bram Moolenaardff97e62022-01-24 20:00:55 +00002084func Test_setbufvar_keep_window_title()
2085 CheckRunVimInTerminal
Bram Moolenaara6c09a72022-01-24 22:02:15 +00002086 if !has('title') || empty(&t_ts)
2087 throw "Skipped: can't get/set title"
2088 endif
Bram Moolenaardff97e62022-01-24 20:00:55 +00002089
2090 let lines =<< trim END
Bram Moolenaar14501122022-01-24 22:32:28 +00002091 set title
Bram Moolenaardff97e62022-01-24 20:00:55 +00002092 edit Xa.txt
2093 let g:buf = bufadd('Xb.txt')
2094 inoremap <F2> <C-R>=setbufvar(g:buf, '&autoindent', 1) ?? ''<CR>
2095 END
Bram Moolenaar70e67252022-09-27 19:34:35 +01002096 call writefile(lines, 'Xsetbufvar', 'D')
Bram Moolenaardff97e62022-01-24 20:00:55 +00002097 let buf = RunVimInTerminal('-S Xsetbufvar', {})
Bram Moolenaar3a8ad592022-01-24 22:18:24 +00002098 call WaitForAssert({-> assert_match('Xa.txt', term_gettitle(buf))}, 1000)
Bram Moolenaardff97e62022-01-24 20:00:55 +00002099
2100 call term_sendkeys(buf, "i\<F2>")
2101 call TermWait(buf)
2102 call term_sendkeys(buf, "\<Esc>")
2103 call TermWait(buf)
2104 call assert_match('Xa.txt', term_gettitle(buf))
2105
2106 call StopVimInTerminal(buf)
Bram Moolenaardff97e62022-01-24 20:00:55 +00002107endfunc
2108
Bram Moolenaard4863aa2017-04-07 19:50:12 +02002109func Test_redo_in_nested_functions()
2110 nnoremap g. :set opfunc=Operator<CR>g@
2111 function Operator( type, ... )
2112 let @x = 'XXX'
2113 execute 'normal! g`[' . (a:type ==# 'line' ? 'V' : 'v') . 'g`]' . '"xp'
2114 endfunction
2115
2116 function! Apply()
2117 5,6normal! .
2118 endfunction
2119
2120 new
2121 call setline(1, repeat(['some "quoted" text', 'more "quoted" text'], 3))
2122 1normal g.i"
2123 call assert_equal('some "XXX" text', getline(1))
2124 3,4normal .
2125 call assert_equal('some "XXX" text', getline(3))
2126 call assert_equal('more "XXX" text', getline(4))
2127 call Apply()
2128 call assert_equal('some "XXX" text', getline(5))
2129 call assert_equal('more "XXX" text', getline(6))
2130 bwipe!
2131
2132 nunmap g.
2133 delfunc Operator
2134 delfunc Apply
2135endfunc
Bram Moolenaar20615522017-06-05 18:46:26 +02002136
Bram Moolenaar295ac5a2018-03-22 23:04:02 +01002137func Test_trim()
2138 call assert_equal("Testing", trim(" \t\r\r\x0BTesting \t\n\r\n\t\x0B\x0B"))
Bram Moolenaarf92e58c2019-09-08 21:51:41 +02002139 call assert_equal("Testing", " \t \r\r\n\n\x0BTesting \t\n\r\n\t\x0B\x0B"->trim())
Bram Moolenaar295ac5a2018-03-22 23:04:02 +01002140 call assert_equal("RESERVE", trim("xyz \twwRESERVEzyww \t\t", " wxyz\t"))
2141 call assert_equal("wRE \tSERVEzyww", trim("wRE \tSERVEzyww"))
2142 call assert_equal("abcd\t xxxx tail", trim(" \tabcd\t xxxx tail"))
2143 call assert_equal("\tabcd\t xxxx tail", trim(" \tabcd\t xxxx tail", " "))
2144 call assert_equal(" \tabcd\t xxxx tail", trim(" \tabcd\t xxxx tail", "abx"))
2145 call assert_equal("RESERVE", trim("RESERVE", "你好"))
2146 call assert_equal("R E SER V E", trim("你好您R E SER V E早好你你", "你好"))
2147 call assert_equal("你好您R E SER V E早好你你", trim(" \n\r\r 你好您R E SER V E早好你你 \t \x0B", ))
2148 call assert_equal("R E SER V E早好你你 \t \x0B", trim(" 你好您R E SER V E早好你你 \t \x0B", " 你好"))
2149 call assert_equal("R E SER V E早好你你 \t \x0B", trim(" tteesstttt你好您R E SER V E早好你你 \t \x0B ttestt", " 你好tes"))
2150 call assert_equal("R E SER V E早好你你 \t \x0B", trim(" tteesstttt你好您R E SER V E早好你你 \t \x0B ttestt", " 你你你好好好tttsses"))
2151 call assert_equal("留下", trim("这些些不要这些留下这些", "这些不要"))
2152 call assert_equal("", trim("", ""))
2153 call assert_equal("a", trim("a", ""))
2154 call assert_equal("", trim("", "a"))
2155
Bram Moolenaar2245ae12020-05-31 22:20:36 +02002156 call assert_equal("vim", trim(" vim ", " ", 0))
2157 call assert_equal("vim ", trim(" vim ", " ", 1))
2158 call assert_equal(" vim", trim(" vim ", " ", 2))
2159 call assert_fails('eval trim(" vim ", " ", [])', 'E745:')
2160 call assert_fails('eval trim(" vim ", " ", -1)', 'E475:')
2161 call assert_fails('eval trim(" vim ", " ", 3)', 'E475:')
Yegappan Lakshmanan8deb2b32022-09-02 15:15:27 +01002162 call assert_fails('eval trim(" vim ", 0)', 'E1174:')
Bram Moolenaar2245ae12020-05-31 22:20:36 +02002163
Bram Moolenaar3f4f3d82019-09-04 20:05:59 +02002164 let chars = join(map(range(1, 0x20) + [0xa0], {n -> n->nr2char()}), '')
Bram Moolenaar295ac5a2018-03-22 23:04:02 +01002165 call assert_equal("x", trim(chars . "x" . chars))
Bram Moolenaar0e05de42020-03-25 22:23:46 +01002166
2167 call assert_fails('let c=trim([])', 'E730:')
Bram Moolenaar295ac5a2018-03-22 23:04:02 +01002168endfunc
Bram Moolenaar0b6d9112018-05-22 20:35:17 +02002169
2170" Test for reg_recording() and reg_executing()
2171func Test_reg_executing_and_recording()
2172 let s:reg_stat = ''
2173 func s:save_reg_stat()
2174 let s:reg_stat = reg_recording() . ':' . reg_executing()
2175 return ''
2176 endfunc
2177
2178 new
2179 call s:save_reg_stat()
2180 call assert_equal(':', s:reg_stat)
2181 call feedkeys("qa\"=s:save_reg_stat()\<CR>pq", 'xt')
2182 call assert_equal('a:', s:reg_stat)
2183 call feedkeys("@a", 'xt')
2184 call assert_equal(':a', s:reg_stat)
2185 call feedkeys("qb@aq", 'xt')
2186 call assert_equal('b:a', s:reg_stat)
2187 call feedkeys("q\"\"=s:save_reg_stat()\<CR>pq", 'xt')
2188 call assert_equal('":', s:reg_stat)
2189
Bram Moolenaarcce713d2019-03-04 11:40:12 +01002190 " :normal command saves and restores reg_executing
Bram Moolenaarf0fab302019-03-05 12:24:10 +01002191 let s:reg_stat = ''
Bram Moolenaarcce713d2019-03-04 11:40:12 +01002192 let @q = ":call TestFunc()\<CR>:call s:save_reg_stat()\<CR>"
2193 func TestFunc() abort
2194 normal! ia
2195 endfunc
2196 call feedkeys("@q", 'xt')
2197 call assert_equal(':q', s:reg_stat)
2198 delfunc TestFunc
2199
Bram Moolenaarf0fab302019-03-05 12:24:10 +01002200 " getchar() command saves and restores reg_executing
2201 map W :call TestFunc()<CR>
2202 let @q = "W"
Bram Moolenaar9a2c0912019-03-30 14:26:18 +01002203 let g:typed = ''
2204 let g:regs = []
Bram Moolenaarf0fab302019-03-05 12:24:10 +01002205 func TestFunc() abort
Bram Moolenaar9a2c0912019-03-30 14:26:18 +01002206 let g:regs += [reg_executing()]
Bram Moolenaarf0fab302019-03-05 12:24:10 +01002207 let g:typed = getchar(0)
Bram Moolenaar9a2c0912019-03-30 14:26:18 +01002208 let g:regs += [reg_executing()]
Bram Moolenaarf0fab302019-03-05 12:24:10 +01002209 endfunc
2210 call feedkeys("@qy", 'xt')
2211 call assert_equal(char2nr("y"), g:typed)
Bram Moolenaar9a2c0912019-03-30 14:26:18 +01002212 call assert_equal(['q', 'q'], g:regs)
Bram Moolenaarf0fab302019-03-05 12:24:10 +01002213 delfunc TestFunc
2214 unmap W
2215 unlet g:typed
Bram Moolenaar9a2c0912019-03-30 14:26:18 +01002216 unlet g:regs
2217
2218 " input() command saves and restores reg_executing
2219 map W :call TestFunc()<CR>
2220 let @q = "W"
2221 let g:typed = ''
2222 let g:regs = []
2223 func TestFunc() abort
2224 let g:regs += [reg_executing()]
Bram Moolenaarf9f24ce2019-08-31 21:17:39 +02002225 let g:typed = '?'->input()
Bram Moolenaar9a2c0912019-03-30 14:26:18 +01002226 let g:regs += [reg_executing()]
2227 endfunc
2228 call feedkeys("@qy\<CR>", 'xt')
2229 call assert_equal("y", g:typed)
2230 call assert_equal(['q', 'q'], g:regs)
2231 delfunc TestFunc
2232 unmap W
2233 unlet g:typed
2234 unlet g:regs
Bram Moolenaarf0fab302019-03-05 12:24:10 +01002235
Bram Moolenaar0b6d9112018-05-22 20:35:17 +02002236 bwipe!
2237 delfunc s:save_reg_stat
2238 unlet s:reg_stat
2239endfunc
Bram Moolenaar1ceebb42018-06-19 19:46:06 +02002240
Bram Moolenaarf9f24ce2019-08-31 21:17:39 +02002241func Test_inputsecret()
2242 map W :call TestFunc()<CR>
2243 let @q = "W"
2244 let g:typed1 = ''
2245 let g:typed2 = ''
2246 let g:regs = []
2247 func TestFunc() abort
2248 let g:typed1 = '?'->inputsecret()
2249 let g:typed2 = inputsecret('password: ')
2250 endfunc
2251 call feedkeys("@qsomething\<CR>else\<CR>", 'xt')
2252 call assert_equal("something", g:typed1)
2253 call assert_equal("else", g:typed2)
2254 delfunc TestFunc
2255 unmap W
2256 unlet g:typed1
2257 unlet g:typed2
2258endfunc
2259
Bram Moolenaar5d712e42019-09-03 23:37:01 +02002260func Test_getchar()
2261 call feedkeys('a', '')
2262 call assert_equal(char2nr('a'), getchar())
Bram Moolenaar3a7503c2021-06-07 18:29:17 +02002263 call assert_equal(0, getchar(0))
2264 call assert_equal(0, getchar(1))
2265
2266 call feedkeys('a', '')
2267 call assert_equal('a', getcharstr())
2268 call assert_equal('', getcharstr(0))
2269 call assert_equal('', getcharstr(1))
Bram Moolenaar5d712e42019-09-03 23:37:01 +02002270
zeertzjqad6c45f2022-02-20 19:05:10 +00002271 call feedkeys("\<M-F2>", '')
2272 call assert_equal("\<M-F2>", getchar(0))
2273 call assert_equal(0, getchar(0))
2274
Bram Moolenaardb3a2052019-11-16 18:22:41 +01002275 call setline(1, 'xxxx')
Bram Moolenaar5d712e42019-09-03 23:37:01 +02002276 call test_setmouse(1, 3)
2277 let v:mouse_win = 9
2278 let v:mouse_winid = 9
2279 let v:mouse_lnum = 9
2280 let v:mouse_col = 9
2281 call feedkeys("\<S-LeftMouse>", '')
2282 call assert_equal("\<S-LeftMouse>", getchar())
2283 call assert_equal(1, v:mouse_win)
2284 call assert_equal(win_getid(1), v:mouse_winid)
2285 call assert_equal(1, v:mouse_lnum)
2286 call assert_equal(3, v:mouse_col)
Bram Moolenaardb3a2052019-11-16 18:22:41 +01002287 enew!
Bram Moolenaar5d712e42019-09-03 23:37:01 +02002288endfunc
2289
Bram Moolenaar1ceebb42018-06-19 19:46:06 +02002290func Test_libcall_libcallnr()
Bram Moolenaar6d91bcb2020-08-12 18:50:36 +02002291 CheckFeature libcall
Bram Moolenaar1ceebb42018-06-19 19:46:06 +02002292
2293 if has('win32')
2294 let libc = 'msvcrt.dll'
2295 elseif has('mac')
2296 let libc = 'libSystem.B.dylib'
Bram Moolenaar39536dd2019-01-29 22:58:21 +01002297 elseif executable('ldd')
2298 let libc = matchstr(split(system('ldd ' . GetVimProg())), '/libc\.so\>')
2299 endif
2300 if get(l:, 'libc', '') ==# ''
Bram Moolenaar1ceebb42018-06-19 19:46:06 +02002301 " On Unix, libc.so can be in various places.
Bram Moolenaar39536dd2019-01-29 22:58:21 +01002302 if has('linux')
2303 " There is not documented but regarding the 1st argument of glibc's
2304 " dlopen an empty string and nullptr are equivalent, so using an empty
2305 " string for the 1st argument of libcall allows to call functions.
2306 let libc = ''
2307 elseif has('sun')
2308 " Set the path to libc.so according to the architecture.
2309 let test_bits = system('file ' . GetVimProg())
2310 let test_arch = system('uname -p')
2311 if test_bits =~ '64-bit' && test_arch =~ 'sparc'
2312 let libc = '/usr/lib/sparcv9/libc.so'
2313 elseif test_bits =~ '64-bit' && test_arch =~ 'i386'
2314 let libc = '/usr/lib/amd64/libc.so'
2315 else
2316 let libc = '/usr/lib/libc.so'
2317 endif
2318 else
2319 " Unfortunately skip this test until a good way is found.
2320 return
2321 endif
Bram Moolenaar1ceebb42018-06-19 19:46:06 +02002322 endif
2323
2324 if has('win32')
Bram Moolenaar02b31112019-08-31 22:16:38 +02002325 call assert_equal($USERPROFILE, 'USERPROFILE'->libcall(libc, 'getenv'))
Bram Moolenaar1ceebb42018-06-19 19:46:06 +02002326 else
Bram Moolenaar02b31112019-08-31 22:16:38 +02002327 call assert_equal($HOME, 'HOME'->libcall(libc, 'getenv'))
Bram Moolenaar1ceebb42018-06-19 19:46:06 +02002328 endif
2329
2330 " If function returns NULL, libcall() should return an empty string.
2331 call assert_equal('', libcall(libc, 'getenv', 'X_ENV_DOES_NOT_EXIT'))
2332
2333 " Test libcallnr() with string and integer argument.
Bram Moolenaar02b31112019-08-31 22:16:38 +02002334 call assert_equal(4, 'abcd'->libcallnr(libc, 'strlen'))
2335 call assert_equal(char2nr('A'), char2nr('a')->libcallnr(libc, 'toupper'))
Bram Moolenaar1ceebb42018-06-19 19:46:06 +02002336
Bram Moolenaar9b7bf9e2020-07-11 22:14:59 +02002337 call assert_fails("call libcall(libc, 'Xdoesnotexist_', '')", ['', 'E364:'])
2338 call assert_fails("call libcallnr(libc, 'Xdoesnotexist_', '')", ['', 'E364:'])
Bram Moolenaar1ceebb42018-06-19 19:46:06 +02002339
Bram Moolenaar9b7bf9e2020-07-11 22:14:59 +02002340 call assert_fails("call libcall('Xdoesnotexist_', 'getenv', 'HOME')", ['', 'E364:'])
2341 call assert_fails("call libcallnr('Xdoesnotexist_', 'strlen', 'abcd')", ['', 'E364:'])
Bram Moolenaar1ceebb42018-06-19 19:46:06 +02002342endfunc
Bram Moolenaard90a1442018-07-15 20:24:31 +02002343
2344sandbox function Fsandbox()
2345 normal ix
2346endfunc
2347
2348func Test_func_sandbox()
2349 sandbox let F = {-> 'hello'}
2350 call assert_equal('hello', F())
2351
Bram Moolenaara4208962019-08-24 20:50:19 +02002352 sandbox let F = {-> "normal ix\<Esc>"->execute()}
Bram Moolenaard90a1442018-07-15 20:24:31 +02002353 call assert_fails('call F()', 'E48:')
2354 unlet F
2355
2356 call assert_fails('call Fsandbox()', 'E48:')
2357 delfunc Fsandbox
Bram Moolenaar8dfcce32020-03-18 19:32:26 +01002358
2359 " From a sandbox try to set a predefined variable (which cannot be modified
2360 " from a sandbox)
2361 call assert_fails('sandbox let v:lnum = 10', 'E794:')
Bram Moolenaard90a1442018-07-15 20:24:31 +02002362endfunc
Bram Moolenaar9e353b52018-11-04 23:39:38 +01002363
2364func EditAnotherFile()
2365 let word = expand('<cword>')
2366 edit Xfuncrange2
2367endfunc
2368
2369func Test_func_range_with_edit()
2370 " Define a function that edits another buffer, then call it with a range that
2371 " is invalid in that buffer.
Bram Moolenaar70e67252022-09-27 19:34:35 +01002372 call writefile(['just one line'], 'Xfuncrange2', 'D')
Bram Moolenaar9e353b52018-11-04 23:39:38 +01002373 new
Bram Moolenaar196b4662019-09-06 21:34:30 +02002374 eval 10->range()->setline(1)
Bram Moolenaar9e353b52018-11-04 23:39:38 +01002375 write Xfuncrange1
2376 call assert_fails('5,8call EditAnotherFile()', 'E16:')
2377
2378 call delete('Xfuncrange1')
Bram Moolenaar9e353b52018-11-04 23:39:38 +01002379 bwipe!
2380endfunc
Bram Moolenaarded5f1b2018-11-10 17:33:29 +01002381
2382func Test_func_exists_on_reload()
Bram Moolenaar70e67252022-09-27 19:34:35 +01002383 call writefile(['func ExistingFunction()', 'echo "yes"', 'endfunc'], 'Xfuncexists', 'D')
Bram Moolenaarded5f1b2018-11-10 17:33:29 +01002384 call assert_equal(0, exists('*ExistingFunction'))
2385 source Xfuncexists
Bram Moolenaara4208962019-08-24 20:50:19 +02002386 call assert_equal(1, '*ExistingFunction'->exists())
Bram Moolenaarded5f1b2018-11-10 17:33:29 +01002387 " Redefining a function when reloading a script is OK.
2388 source Xfuncexists
2389 call assert_equal(1, exists('*ExistingFunction'))
2390
2391 " But redefining in another script is not OK.
Bram Moolenaar70e67252022-09-27 19:34:35 +01002392 call writefile(['func ExistingFunction()', 'echo "yes"', 'endfunc'], 'Xfuncexists2', 'D')
Bram Moolenaarded5f1b2018-11-10 17:33:29 +01002393 call assert_fails('source Xfuncexists2', 'E122:')
2394
Yegappan Lakshmanan611728f2021-05-24 15:15:47 +02002395 " Defining a new function from the cmdline should fail if the function is
2396 " already defined
2397 call assert_fails('call feedkeys(":func ExistingFunction()\<CR>", "xt")', 'E122:')
2398
Bram Moolenaarded5f1b2018-11-10 17:33:29 +01002399 delfunc ExistingFunction
2400 call assert_equal(0, exists('*ExistingFunction'))
2401 call writefile([
2402 \ 'func ExistingFunction()', 'echo "yes"', 'endfunc',
2403 \ 'func ExistingFunction()', 'echo "no"', 'endfunc',
2404 \ ], 'Xfuncexists')
2405 call assert_fails('source Xfuncexists', 'E122:')
2406 call assert_equal(1, exists('*ExistingFunction'))
2407
Bram Moolenaarded5f1b2018-11-10 17:33:29 +01002408 delfunc ExistingFunction
2409endfunc
Bram Moolenaar2e050092019-01-27 15:00:36 +01002410
2411" Test confirm({msg} [, {choices} [, {default} [, {type}]]])
2412func Test_confirm()
Bram Moolenaar8c5a2782019-08-07 23:07:07 +02002413 CheckUnix
2414 CheckNotGui
Bram Moolenaar2e050092019-01-27 15:00:36 +01002415
2416 call feedkeys('o', 'L')
2417 let a = confirm('Press O to proceed')
2418 call assert_equal(1, a)
2419
2420 call feedkeys('y', 'L')
Bram Moolenaar1a3a8912019-08-23 22:31:37 +02002421 let a = 'Are you sure?'->confirm("&Yes\n&No")
Bram Moolenaar2e050092019-01-27 15:00:36 +01002422 call assert_equal(1, a)
2423
2424 call feedkeys('n', 'L')
2425 let a = confirm('Are you sure?', "&Yes\n&No")
2426 call assert_equal(2, a)
2427
2428 " confirm() should return 0 when pressing CTRL-C.
Bram Moolenaar79296512020-03-22 16:17:14 +01002429 call feedkeys("\<C-C>", 'L')
Bram Moolenaar2e050092019-01-27 15:00:36 +01002430 let a = confirm('Are you sure?', "&Yes\n&No")
2431 call assert_equal(0, a)
2432
2433 " <Esc> requires another character to avoid it being seen as the start of an
2434 " escape sequence. Zero should be harmless.
Bram Moolenaara4208962019-08-24 20:50:19 +02002435 eval "\<Esc>0"->feedkeys('L')
Bram Moolenaar2e050092019-01-27 15:00:36 +01002436 let a = confirm('Are you sure?', "&Yes\n&No")
2437 call assert_equal(0, a)
2438
2439 " Default choice is returned when pressing <CR>.
2440 call feedkeys("\<CR>", 'L')
2441 let a = confirm('Are you sure?', "&Yes\n&No")
2442 call assert_equal(1, a)
2443
2444 call feedkeys("\<CR>", 'L')
2445 let a = confirm('Are you sure?', "&Yes\n&No", 2)
2446 call assert_equal(2, a)
2447
2448 call feedkeys("\<CR>", 'L')
2449 let a = confirm('Are you sure?', "&Yes\n&No", 0)
2450 call assert_equal(0, a)
2451
2452 " Test with the {type} 4th argument
2453 for type in ['Error', 'Question', 'Info', 'Warning', 'Generic']
2454 call feedkeys('y', 'L')
2455 let a = confirm('Are you sure?', "&Yes\n&No\n", 1, type)
2456 call assert_equal(1, a)
2457 endfor
2458
2459 call assert_fails('call confirm([])', 'E730:')
2460 call assert_fails('call confirm("Are you sure?", [])', 'E730:')
2461 call assert_fails('call confirm("Are you sure?", "&Yes\n&No\n", [])', 'E745:')
2462 call assert_fails('call confirm("Are you sure?", "&Yes\n&No\n", 0, [])', 'E730:')
2463endfunc
Bram Moolenaar39536dd2019-01-29 22:58:21 +01002464
2465func Test_platform_name()
2466 " The system matches at most only one name.
Bram Moolenaar041c7102020-05-30 18:14:57 +02002467 let names = ['amiga', 'bsd', 'hpux', 'linux', 'mac', 'qnx', 'sun', 'vms', 'win32', 'win32unix']
Bram Moolenaar39536dd2019-01-29 22:58:21 +01002468 call assert_inrange(0, 1, len(filter(copy(names), 'has(v:val)')))
2469
2470 " Is Unix?
Bram Moolenaar39536dd2019-01-29 22:58:21 +01002471 call assert_equal(has('bsd'), has('bsd') && has('unix'))
2472 call assert_equal(has('hpux'), has('hpux') && has('unix'))
2473 call assert_equal(has('linux'), has('linux') && has('unix'))
2474 call assert_equal(has('mac'), has('mac') && has('unix'))
2475 call assert_equal(has('qnx'), has('qnx') && has('unix'))
2476 call assert_equal(has('sun'), has('sun') && has('unix'))
2477 call assert_equal(has('win32'), has('win32') && !has('unix'))
2478 call assert_equal(has('win32unix'), has('win32unix') && has('unix'))
2479
2480 if has('unix') && executable('uname')
2481 let uname = system('uname')
Bram Moolenaara02e3f62019-02-07 21:27:14 +01002482 " GNU userland on BSD kernels (e.g., GNU/kFreeBSD) don't have BSD defined
2483 call assert_equal(uname =~? '\%(GNU/k\w\+\)\@<!BSD\|DragonFly', has('bsd'))
Bram Moolenaar39536dd2019-01-29 22:58:21 +01002484 call assert_equal(uname =~? 'HP-UX', has('hpux'))
2485 call assert_equal(uname =~? 'Linux', has('linux'))
2486 call assert_equal(uname =~? 'Darwin', has('mac'))
2487 call assert_equal(uname =~? 'QNX', has('qnx'))
2488 call assert_equal(uname =~? 'SunOS', has('sun'))
2489 call assert_equal(uname =~? 'CYGWIN\|MSYS', has('win32unix'))
2490 endif
2491endfunc
Bram Moolenaar543c9b12019-04-05 22:50:40 +02002492
2493func Test_readdir()
Bram Moolenaar70e67252022-09-27 19:34:35 +01002494 call mkdir('Xreaddir', 'R')
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002495 call writefile([], 'Xreaddir/foo.txt')
2496 call writefile([], 'Xreaddir/bar.txt')
2497 call mkdir('Xreaddir/dir')
Bram Moolenaar543c9b12019-04-05 22:50:40 +02002498
2499 " All results
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002500 let files = readdir('Xreaddir')
Bram Moolenaar543c9b12019-04-05 22:50:40 +02002501 call assert_equal(['bar.txt', 'dir', 'foo.txt'], sort(files))
2502
2503 " Only results containing "f"
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002504 let files = 'Xreaddir'->readdir({ x -> stridx(x, 'f') != -1 })
Bram Moolenaar543c9b12019-04-05 22:50:40 +02002505 call assert_equal(['foo.txt'], sort(files))
2506
2507 " Only .txt files
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002508 let files = readdir('Xreaddir', { x -> x =~ '.txt$' })
Bram Moolenaar543c9b12019-04-05 22:50:40 +02002509 call assert_equal(['bar.txt', 'foo.txt'], sort(files))
2510
2511 " Only .txt files with string
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002512 let files = readdir('Xreaddir', 'v:val =~ ".txt$"')
Bram Moolenaar543c9b12019-04-05 22:50:40 +02002513 call assert_equal(['bar.txt', 'foo.txt'], sort(files))
2514
2515 " Limit to 1 result.
2516 let l = []
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002517 let files = readdir('Xreaddir', {x -> len(add(l, x)) == 2 ? -1 : 1})
Bram Moolenaar543c9b12019-04-05 22:50:40 +02002518 call assert_equal(1, len(files))
2519
Bram Moolenaar27da7de2019-09-03 17:13:37 +02002520 " Nested readdir() must not crash
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002521 let files = readdir('Xreaddir', 'readdir("Xreaddir", "1") != []')
Bram Moolenaar27da7de2019-09-03 17:13:37 +02002522 call sort(files)->assert_equal(['bar.txt', 'dir', 'foo.txt'])
Bram Moolenaar543c9b12019-04-05 22:50:40 +02002523endfunc
Bram Moolenaar17aca702019-05-16 22:24:55 +02002524
Bram Moolenaar6c9ba042020-06-01 16:09:41 +02002525func Test_readdirex()
Bram Moolenaar70e67252022-09-27 19:34:35 +01002526 call mkdir('Xexdir', 'R')
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002527 call writefile(['foo'], 'Xexdir/foo.txt')
2528 call writefile(['barbar'], 'Xexdir/bar.txt')
2529 call mkdir('Xexdir/dir')
Bram Moolenaar6c9ba042020-06-01 16:09:41 +02002530
2531 " All results
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002532 let files = readdirex('Xexdir')->map({-> v:val.name})
Bram Moolenaar6c9ba042020-06-01 16:09:41 +02002533 call assert_equal(['bar.txt', 'dir', 'foo.txt'], sort(files))
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002534 let sizes = readdirex('Xexdir')->map({-> v:val.size})
Bram Moolenaar441d60e2020-06-02 22:19:50 +02002535 call assert_equal([0, 4, 7], sort(sizes))
Bram Moolenaar6c9ba042020-06-01 16:09:41 +02002536
2537 " Only results containing "f"
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002538 let files = 'Xexdir'->readdirex({ e -> stridx(e.name, 'f') != -1 })
Bram Moolenaar6c9ba042020-06-01 16:09:41 +02002539 \ ->map({-> v:val.name})
2540 call assert_equal(['foo.txt'], sort(files))
2541
2542 " Only .txt files
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002543 let files = readdirex('Xexdir', { e -> e.name =~ '.txt$' })
Bram Moolenaar6c9ba042020-06-01 16:09:41 +02002544 \ ->map({-> v:val.name})
2545 call assert_equal(['bar.txt', 'foo.txt'], sort(files))
2546
2547 " Only .txt files with string
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002548 let files = readdirex('Xexdir', 'v:val.name =~ ".txt$"')
Bram Moolenaar6c9ba042020-06-01 16:09:41 +02002549 \ ->map({-> v:val.name})
2550 call assert_equal(['bar.txt', 'foo.txt'], sort(files))
2551
2552 " Limit to 1 result.
2553 let l = []
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002554 let files = readdirex('Xexdir', {e -> len(add(l, e.name)) == 2 ? -1 : 1})
Bram Moolenaar6c9ba042020-06-01 16:09:41 +02002555 \ ->map({-> v:val.name})
2556 call assert_equal(1, len(files))
2557
2558 " Nested readdirex() must not crash
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002559 let files = readdirex('Xexdir', 'readdirex("Xexdir", "1") != []')
Bram Moolenaar6c9ba042020-06-01 16:09:41 +02002560 \ ->map({-> v:val.name})
2561 call sort(files)->assert_equal(['bar.txt', 'dir', 'foo.txt'])
2562
Bram Moolenaarfdcbe3c2020-06-15 21:41:56 +02002563 " report broken link correctly
Bram Moolenaarab540322020-06-10 15:55:36 +02002564 if has("unix")
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002565 call writefile([], 'Xexdir/abc.txt')
2566 call system("ln -s Xexdir/abc.txt Xexdir/link")
2567 call delete('Xexdir/abc.txt')
2568 let files = readdirex('Xexdir', 'readdirex("Xexdir", "1") != []')
Bram Moolenaarab540322020-06-10 15:55:36 +02002569 \ ->map({-> v:val.name .. '_' .. v:val.type})
2570 call sort(files)->assert_equal(
2571 \ ['bar.txt_file', 'dir_dir', 'foo.txt_file', 'link_link'])
2572 endif
Bram Moolenaaraab9fad2020-10-11 14:28:11 +02002573
2574 call assert_fails('call readdirex("doesnotexist")', 'E484:')
Bram Moolenaar6c9ba042020-06-01 16:09:41 +02002575endfunc
2576
Bram Moolenaar84cf6bd2020-06-16 20:03:43 +02002577func Test_readdirex_sort()
2578 CheckUnix
2579 " Skip tests on Mac OS X and Cygwin (does not allow several files with different casing)
2580 if has("osxdarwin") || has("osx") || has("macunix") || has("win32unix")
2581 throw 'Skipped: Test_readdirex_sort on systems that do not allow this using the default filesystem'
2582 endif
2583 let _collate = v:collate
Bram Moolenaar70e67252022-09-27 19:34:35 +01002584 call mkdir('Xsortdir2', 'R')
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002585 call writefile(['1'], 'Xsortdir2/README.txt')
2586 call writefile(['2'], 'Xsortdir2/Readme.txt')
2587 call writefile(['3'], 'Xsortdir2/readme.txt')
Bram Moolenaar84cf6bd2020-06-16 20:03:43 +02002588
2589 " 1) default
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002590 let files = readdirex('Xsortdir2')->map({-> v:val.name})
Bram Moolenaar84cf6bd2020-06-16 20:03:43 +02002591 let default = copy(files)
2592 call assert_equal(['README.txt', 'Readme.txt', 'readme.txt'], files, 'sort using default')
2593
2594 " 2) no sorting
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002595 let files = readdirex('Xsortdir2', 1, #{sort: 'none'})->map({-> v:val.name})
Bram Moolenaar84cf6bd2020-06-16 20:03:43 +02002596 let unsorted = copy(files)
2597 call assert_equal(['README.txt', 'Readme.txt', 'readme.txt'], sort(files), 'unsorted')
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002598 call assert_fails("call readdirex('Xsortdir2', 1, #{slort: 'none'})", 'E857: Dictionary key "sort" required')
Bram Moolenaar84cf6bd2020-06-16 20:03:43 +02002599
2600 " 3) sort by case (same as default)
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002601 let files = readdirex('Xsortdir2', 1, #{sort: 'case'})->map({-> v:val.name})
Bram Moolenaar84cf6bd2020-06-16 20:03:43 +02002602 call assert_equal(default, files, 'sort by case')
2603
2604 " 4) sort by ignoring case
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002605 let files = readdirex('Xsortdir2', 1, #{sort: 'icase'})->map({-> v:val.name})
Bram Moolenaar84cf6bd2020-06-16 20:03:43 +02002606 call assert_equal(unsorted->sort('i'), files, 'sort by icase')
2607
2608 " 5) Default Collation
2609 let collate = v:collate
2610 lang collate C
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002611 let files = readdirex('Xsortdir2', 1, #{sort: 'collate'})->map({-> v:val.name})
Bram Moolenaar84cf6bd2020-06-16 20:03:43 +02002612 call assert_equal(['README.txt', 'Readme.txt', 'readme.txt'], files, 'sort by C collation')
2613
2614 " 6) Collation de_DE
2615 " Switch locale, this may not work on the CI system, if the locale isn't
2616 " available
2617 try
2618 lang collate de_DE
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002619 let files = readdirex('Xsortdir2', 1, #{sort: 'collate'})->map({-> v:val.name})
Bram Moolenaar84cf6bd2020-06-16 20:03:43 +02002620 call assert_equal(['readme.txt', 'Readme.txt', 'README.txt'], files, 'sort by de_DE collation')
2621 catch
2622 throw 'Skipped: de_DE collation is not available'
2623
2624 finally
2625 exe 'lang collate' collate
Bram Moolenaar84cf6bd2020-06-16 20:03:43 +02002626 endtry
2627endfunc
2628
2629func Test_readdir_sort()
2630 " some more cases for testing sorting for readdirex
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002631 let dir = 'Xsortdir3'
Bram Moolenaar70e67252022-09-27 19:34:35 +01002632 call mkdir(dir, 'R')
Bram Moolenaar84cf6bd2020-06-16 20:03:43 +02002633 call writefile(['1'], dir .. '/README.txt')
2634 call writefile(['2'], dir .. '/Readm.txt')
2635 call writefile(['3'], dir .. '/read.txt')
2636 call writefile(['4'], dir .. '/Z.txt')
2637 call writefile(['5'], dir .. '/a.txt')
2638 call writefile(['6'], dir .. '/b.txt')
2639
2640 " 1) default
2641 let files = readdir(dir)
2642 let default = copy(files)
2643 call assert_equal(default->sort(), files, 'sort using default')
2644
2645 " 2) sort by case (same as default)
2646 let files = readdir(dir, '1', #{sort: 'case'})
2647 call assert_equal(default, files, 'sort using default')
2648
2649 " 3) sort by ignoring case
2650 let files = readdir(dir, '1', #{sort: 'icase'})
2651 call assert_equal(default->sort('i'), files, 'sort by ignoring case')
2652
Bram Moolenaare17f8812020-06-17 20:30:44 +02002653 " 4) collation
2654 let collate = v:collate
2655 lang collate C
2656 let files = readdir(dir, 1, #{sort: 'collate'})
2657 call assert_equal(default->sort(), files, 'sort by C collation')
2658 exe "lang collate" collate
2659
2660 " 5) Errors
Bram Moolenaard83392a2022-09-01 12:22:46 +01002661 call assert_fails('call readdir(dir, 1, 1)', 'E1206:')
Bram Moolenaare17f8812020-06-17 20:30:44 +02002662 call assert_fails('call readdir(dir, 1, #{sorta: 1})')
Bram Moolenaard83392a2022-09-01 12:22:46 +01002663 call assert_fails('call readdir(dir, 1, test_null_dict())', 'E1297:')
2664 call assert_fails('call readdirex(dir, 1, 1)', 'E1206:')
Bram Moolenaare17f8812020-06-17 20:30:44 +02002665 call assert_fails('call readdirex(dir, 1, #{sorta: 1})')
Bram Moolenaard83392a2022-09-01 12:22:46 +01002666 call assert_fails('call readdirex(dir, 1, test_null_dict())', 'E1297:')
Bram Moolenaare17f8812020-06-17 20:30:44 +02002667
2668 " 6) ignore other values in dict
2669 let files = readdir(dir, '1', #{sort: 'c'})
2670 call assert_equal(default, files, 'sort using default2')
2671
2672 " Cleanup
2673 exe "lang collate" collate
Bram Moolenaar84cf6bd2020-06-16 20:03:43 +02002674endfunc
2675
Bram Moolenaar701ff0a2019-05-24 14:14:14 +02002676func Test_delete_rf()
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002677 call mkdir('Xrfdir')
2678 call writefile([], 'Xrfdir/foo.txt')
2679 call writefile([], 'Xrfdir/bar.txt')
2680 call mkdir('Xrfdir/[a-1]') " issue #696
2681 call writefile([], 'Xrfdir/[a-1]/foo.txt')
2682 call writefile([], 'Xrfdir/[a-1]/bar.txt')
2683 call assert_true(filereadable('Xrfdir/foo.txt'))
2684 call assert_true('Xrfdir/[a-1]/foo.txt'->filereadable())
Bram Moolenaar701ff0a2019-05-24 14:14:14 +02002685
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002686 call assert_equal(0, delete('Xrfdir', 'rf'))
2687 call assert_false(filereadable('Xrfdir/foo.txt'))
2688 call assert_false(filereadable('Xrfdir/[a-1]/foo.txt'))
zeertzjq47870032022-04-05 15:31:01 +01002689
2690 if has('unix')
Bram Moolenaar3b0d70f2022-08-29 22:31:20 +01002691 call mkdir('Xrfdir/Xdir2', 'p')
2692 silent !chmod 555 Xrfdir
2693 call assert_equal(-1, delete('Xrfdir/Xdir2', 'rf'))
2694 call assert_equal(-1, delete('Xrfdir', 'rf'))
2695 silent !chmod 755 Xrfdir
2696 call assert_equal(0, delete('Xrfdir', 'rf'))
zeertzjq47870032022-04-05 15:31:01 +01002697 endif
Bram Moolenaar701ff0a2019-05-24 14:14:14 +02002698endfunc
2699
Bram Moolenaar17aca702019-05-16 22:24:55 +02002700func Test_call()
2701 call assert_equal(3, call('len', [123]))
Bram Moolenaar64b4d732019-08-22 22:18:17 +02002702 call assert_equal(3, 'len'->call([123]))
Bram Moolenaard83392a2022-09-01 12:22:46 +01002703 call assert_fails("call call('len', 123)", 'E1211:')
Bram Moolenaar17aca702019-05-16 22:24:55 +02002704 call assert_equal(0, call('', []))
Bram Moolenaarad48e6c2020-04-21 22:19:45 +02002705 call assert_equal(0, call('len', test_null_list()))
Bram Moolenaar17aca702019-05-16 22:24:55 +02002706
2707 function Mylen() dict
2708 return len(self.data)
2709 endfunction
2710 let mydict = {'data': [0, 1, 2, 3], 'len': function("Mylen")}
Bram Moolenaar64b4d732019-08-22 22:18:17 +02002711 eval mydict.len->call([], mydict)->assert_equal(4)
Yegappan Lakshmanan04c4c572022-08-30 19:48:24 +01002712 call assert_fails("call call('Mylen', [], 0)", 'E1206:')
Bram Moolenaar67322bf2020-12-06 15:03:19 +01002713 call assert_fails('call foo', 'E107:')
Dominique Pellefe8ebdb2021-05-13 14:55:55 +02002714
Bram Moolenaar22db0d52021-06-12 12:16:55 +02002715 " These once caused a crash.
Dominique Pellefe8ebdb2021-05-13 14:55:55 +02002716 call call(test_null_function(), [])
2717 call call(test_null_partial(), [])
Bram Moolenaar22db0d52021-06-12 12:16:55 +02002718 call assert_fails('call test_null_function()()', 'E1192:')
2719 call assert_fails('call test_null_partial()()', 'E117:')
Bram Moolenaar2ef91562021-12-11 16:14:07 +00002720
2721 let lines =<< trim END
2722 let Time = 'localtime'
2723 call Time()
2724 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002725 call v9.CheckScriptFailure(lines, 'E1085:')
Bram Moolenaar17aca702019-05-16 22:24:55 +02002726endfunc
2727
2728func Test_char2nr()
2729 call assert_equal(12354, char2nr('あ', 1))
Bram Moolenaar1a3a8912019-08-23 22:31:37 +02002730 call assert_equal(120, 'x'->char2nr())
Bram Moolenaar0e05de42020-03-25 22:23:46 +01002731 set encoding=latin1
2732 call assert_equal(120, 'x'->char2nr())
2733 set encoding=utf-8
Bram Moolenaar17aca702019-05-16 22:24:55 +02002734endfunc
2735
Bram Moolenaar4e4473c2020-08-28 22:24:57 +02002736func Test_charclass()
2737 call assert_equal(0, charclass(' '))
2738 call assert_equal(1, charclass('.'))
2739 call assert_equal(2, charclass('x'))
2740 call assert_equal(3, charclass("\u203c"))
Christian Brabandt72463f82021-07-02 20:19:31 +02002741 " this used to crash vim
2742 call assert_equal(0, "xxx"[-1]->charclass())
Bram Moolenaar4e4473c2020-08-28 22:24:57 +02002743endfunc
2744
Bram Moolenaar17aca702019-05-16 22:24:55 +02002745func Test_eventhandler()
2746 call assert_equal(0, eventhandler())
2747endfunc
Bram Moolenaar15e248e2019-06-30 20:21:37 +02002748
2749func Test_bufadd_bufload()
2750 call assert_equal(0, bufexists('someName'))
2751 let buf = bufadd('someName')
2752 call assert_notequal(0, buf)
2753 call assert_equal(1, bufexists('someName'))
2754 call assert_equal(0, getbufvar(buf, '&buflisted'))
2755 call assert_equal(0, bufloaded(buf))
2756 call bufload(buf)
2757 call assert_equal(1, bufloaded(buf))
2758 call assert_equal([''], getbufline(buf, 1, '$'))
2759
2760 let curbuf = bufnr('')
Bram Moolenaarf92e58c2019-09-08 21:51:41 +02002761 eval ['some', 'text']->writefile('XotherName')
Bram Moolenaar073e4b92019-08-18 23:01:56 +02002762 let buf = 'XotherName'->bufadd()
Bram Moolenaar15e248e2019-06-30 20:21:37 +02002763 call assert_notequal(0, buf)
Bram Moolenaar073e4b92019-08-18 23:01:56 +02002764 eval 'XotherName'->bufexists()->assert_equal(1)
Bram Moolenaar15e248e2019-06-30 20:21:37 +02002765 call assert_equal(0, getbufvar(buf, '&buflisted'))
2766 call assert_equal(0, bufloaded(buf))
Bram Moolenaar073e4b92019-08-18 23:01:56 +02002767 eval buf->bufload()
Bram Moolenaar15e248e2019-06-30 20:21:37 +02002768 call assert_equal(1, bufloaded(buf))
2769 call assert_equal(['some', 'text'], getbufline(buf, 1, '$'))
2770 call assert_equal(curbuf, bufnr(''))
2771
Bram Moolenaar892ae722019-06-30 20:33:01 +02002772 let buf1 = bufadd('')
2773 let buf2 = bufadd('')
2774 call assert_notequal(0, buf1)
2775 call assert_notequal(0, buf2)
2776 call assert_notequal(buf1, buf2)
2777 call assert_equal(1, bufexists(buf1))
2778 call assert_equal(1, bufexists(buf2))
2779 call assert_equal(0, bufloaded(buf1))
2780 exe 'bwipe ' .. buf1
2781 call assert_equal(0, bufexists(buf1))
2782 call assert_equal(1, bufexists(buf2))
2783 exe 'bwipe ' .. buf2
2784 call assert_equal(0, bufexists(buf2))
2785
zeertzjq93f72cc2022-08-26 15:34:52 +01002786 " When 'buftype' is "nofile" then bufload() does not read the file.
2787 " Other values too.
2788 for val in [['nofile', 0],
2789 \ ['nowrite', 1],
2790 \ ['acwrite', 1],
2791 \ ['quickfix', 0],
2792 \ ['help', 1],
2793 \ ['terminal', 0],
2794 \ ['prompt', 0],
2795 \ ['popup', 0],
2796 \ ]
2797 bwipe! XotherName
2798 let buf = bufadd('XotherName')
2799 call setbufvar(buf, '&bt', val[0])
2800 call bufload(buf)
2801 call assert_equal(val[1] ? ['some', 'text'] : [''], getbufline(buf, 1, '$'), val[0])
2802 endfor
Bram Moolenaarc3126192022-08-26 12:58:17 +01002803
Bram Moolenaar15e248e2019-06-30 20:21:37 +02002804 bwipe someName
Bram Moolenaar3940ec62019-07-05 21:53:24 +02002805 bwipe XotherName
Bram Moolenaar15e248e2019-06-30 20:21:37 +02002806 call assert_equal(0, bufexists('someName'))
Bram Moolenaar3940ec62019-07-05 21:53:24 +02002807 call delete('XotherName')
Bram Moolenaar15e248e2019-06-30 20:21:37 +02002808endfunc
Bram Moolenaarc2585492019-09-22 21:29:53 +02002809
2810func Test_state()
2811 CheckRunVimInTerminal
2812
Bram Moolenaar3ed9efc2020-03-26 16:50:57 +01002813 let getstate = ":echo 'state: ' .. g:state .. '; mode: ' .. g:mode\<CR>"
2814
Bram Moolenaarc2585492019-09-22 21:29:53 +02002815 let lines =<< trim END
2816 call setline(1, ['one', 'two', 'three'])
2817 map ;; gg
Bram Moolenaarb7a97ef2019-09-28 22:11:56 +02002818 set complete=.
Bram Moolenaarc2585492019-09-22 21:29:53 +02002819 func RunTimer()
2820 call timer_start(10, {id -> execute('let g:state = state()') .. execute('let g:mode = mode()')})
2821 endfunc
2822 au Filetype foobar let g:state = state()|let g:mode = mode()
2823 END
2824 call writefile(lines, 'XState')
2825 let buf = RunVimInTerminal('-S XState', #{rows: 6})
2826
2827 " Using a ":" command Vim is busy, thus "S" is returned
2828 call term_sendkeys(buf, ":echo 'state: ' .. state() .. '; mode: ' .. mode()\<CR>")
2829 call WaitForAssert({-> assert_match('state: S; mode: n', term_getline(buf, 6))}, 1000)
2830 call term_sendkeys(buf, ":\<CR>")
2831
2832 " Using a timer callback
2833 call term_sendkeys(buf, ":call RunTimer()\<CR>")
Bram Moolenaar6a2c5a72020-04-08 21:50:25 +02002834 call TermWait(buf, 25)
Bram Moolenaarc2585492019-09-22 21:29:53 +02002835 call term_sendkeys(buf, getstate)
2836 call WaitForAssert({-> assert_match('state: c; mode: n', term_getline(buf, 6))}, 1000)
2837
2838 " Halfway a mapping
2839 call term_sendkeys(buf, ":call RunTimer()\<CR>;")
Bram Moolenaar6a2c5a72020-04-08 21:50:25 +02002840 call TermWait(buf, 25)
Bram Moolenaarc2585492019-09-22 21:29:53 +02002841 call term_sendkeys(buf, ";")
2842 call term_sendkeys(buf, getstate)
2843 call WaitForAssert({-> assert_match('state: mSc; mode: n', term_getline(buf, 6))}, 1000)
2844
Bram Moolenaarb7a97ef2019-09-28 22:11:56 +02002845 " Insert mode completion (bit slower on Mac)
Bram Moolenaarc2585492019-09-22 21:29:53 +02002846 call term_sendkeys(buf, ":call RunTimer()\<CR>Got\<C-N>")
Bram Moolenaar6a2c5a72020-04-08 21:50:25 +02002847 call TermWait(buf, 25)
Bram Moolenaarc2585492019-09-22 21:29:53 +02002848 call term_sendkeys(buf, "\<Esc>")
2849 call term_sendkeys(buf, getstate)
2850 call WaitForAssert({-> assert_match('state: aSc; mode: i', term_getline(buf, 6))}, 1000)
2851
2852 " Autocommand executing
2853 call term_sendkeys(buf, ":set filetype=foobar\<CR>")
Bram Moolenaar6a2c5a72020-04-08 21:50:25 +02002854 call TermWait(buf, 25)
Bram Moolenaarc2585492019-09-22 21:29:53 +02002855 call term_sendkeys(buf, getstate)
2856 call WaitForAssert({-> assert_match('state: xS; mode: n', term_getline(buf, 6))}, 1000)
2857
2858 " Todo: "w" - waiting for ch_evalexpr()
2859
2860 " messages scrolled
2861 call term_sendkeys(buf, ":call RunTimer()\<CR>:echo \"one\\ntwo\\nthree\"\<CR>")
Bram Moolenaar6a2c5a72020-04-08 21:50:25 +02002862 call TermWait(buf, 25)
Bram Moolenaarc2585492019-09-22 21:29:53 +02002863 call term_sendkeys(buf, "\<CR>")
2864 call term_sendkeys(buf, getstate)
2865 call WaitForAssert({-> assert_match('state: Scs; mode: r', term_getline(buf, 6))}, 1000)
2866
2867 call StopVimInTerminal(buf)
2868 call delete('XState')
2869endfunc
Bram Moolenaar50985eb2020-01-27 22:09:39 +01002870
2871func Test_range()
2872 " destructuring
2873 let [x, y] = range(2)
2874 call assert_equal([0, 1], [x, y])
2875
2876 " index
2877 call assert_equal(4, range(1, 10)[3])
2878
2879 " add()
2880 call assert_equal([0, 1, 2, 3], add(range(3), 3))
2881 call assert_equal([0, 1, 2, [0, 1, 2]], add([0, 1, 2], range(3)))
2882 call assert_equal([0, 1, 2, [0, 1, 2]], add(range(3), range(3)))
2883
2884 " append()
2885 new
2886 call append('.', range(5))
2887 call assert_equal(['', '0', '1', '2', '3', '4'], getline(1, '$'))
2888 bwipe!
2889
2890 " appendbufline()
2891 new
2892 call appendbufline(bufnr(''), '.', range(5))
2893 call assert_equal(['0', '1', '2', '3', '4', ''], getline(1, '$'))
2894 bwipe!
2895
2896 " call()
2897 func TwoArgs(a, b)
2898 return [a:a, a:b]
2899 endfunc
2900 call assert_equal([0, 1], call('TwoArgs', range(2)))
2901
2902 " col()
2903 new
2904 call setline(1, ['foo', 'bar'])
2905 call assert_equal(2, col(range(1, 2)))
2906 bwipe!
2907
2908 " complete()
2909 execute "normal! a\<C-r>=[complete(col('.'), range(10)), ''][1]\<CR>"
2910 " complete_info()
2911 execute "normal! a\<C-r>=[complete(col('.'), range(10)), ''][1]\<CR>\<C-r>=[complete_info(range(5)), ''][1]\<CR>"
2912
2913 " copy()
2914 call assert_equal([1, 2, 3], copy(range(1, 3)))
2915
2916 " count()
2917 call assert_equal(0, count(range(0), 3))
2918 call assert_equal(0, count(range(2), 3))
2919 call assert_equal(1, count(range(5), 3))
2920
2921 " cursor()
2922 new
2923 call setline(1, ['aaa', 'bbb', 'ccc'])
2924 call cursor(range(1, 2))
2925 call assert_equal([2, 1], [col('.'), line('.')])
2926 bwipe!
2927
2928 " deepcopy()
2929 call assert_equal([1, 2, 3], deepcopy(range(1, 3)))
2930
2931 " empty()
2932 call assert_true(empty(range(0)))
2933 call assert_false(empty(range(2)))
2934
2935 " execute()
2936 new
2937 call setline(1, ['aaa', 'bbb', 'ccc'])
2938 call execute(range(3))
2939 call assert_equal(2, line('.'))
2940 bwipe!
2941
2942 " extend()
2943 call assert_equal([1, 2, 3, 4], extend([1], range(2, 4)))
2944 call assert_equal([1, 2, 3, 4], extend(range(1, 1), range(2, 4)))
2945 call assert_equal([1, 2, 3, 4], extend(range(1, 1), [2, 3, 4]))
2946
2947 " filter()
2948 call assert_equal([1, 3], filter(range(5), 'v:val % 2'))
Bram Moolenaarf8ca03b2020-11-28 20:32:29 +01002949 call assert_equal([1, 5, 7, 11, 13], filter(filter(range(15), 'v:val % 2'), 'v:val % 3'))
Bram Moolenaar50985eb2020-01-27 22:09:39 +01002950
2951 " funcref()
2952 call assert_equal([0, 1], funcref('TwoArgs', range(2))())
2953
2954 " function()
2955 call assert_equal([0, 1], function('TwoArgs', range(2))())
2956
2957 " garbagecollect()
2958 let thelist = [1, range(2), 3]
2959 let otherlist = range(3)
2960 call test_garbagecollect_now()
2961
2962 " get()
2963 call assert_equal(4, get(range(1, 10), 3))
2964 call assert_equal(-1, get(range(1, 10), 42, -1))
2965
2966 " index()
2967 call assert_equal(1, index(range(1, 5), 2))
Bram Moolenaar0e05de42020-03-25 22:23:46 +01002968 call assert_fails("echo index([1, 2], 1, [])", 'E745:')
Bram Moolenaar50985eb2020-01-27 22:09:39 +01002969
Bram Moolenaar50985eb2020-01-27 22:09:39 +01002970 " insert()
2971 call assert_equal([42, 1, 2, 3, 4, 5], insert(range(1, 5), 42))
2972 call assert_equal([42, 1, 2, 3, 4, 5], insert(range(1, 5), 42, 0))
2973 call assert_equal([1, 42, 2, 3, 4, 5], insert(range(1, 5), 42, 1))
2974 call assert_equal([1, 2, 3, 4, 42, 5], insert(range(1, 5), 42, 4))
2975 call assert_equal([1, 2, 3, 4, 42, 5], insert(range(1, 5), 42, -1))
2976 call assert_equal([1, 2, 3, 4, 5, 42], insert(range(1, 5), 42, 5))
2977
2978 " join()
2979 call assert_equal('0 1 2 3 4', join(range(5)))
2980
Bram Moolenaar272ca952020-01-28 20:49:11 +01002981 " json_encode()
2982 call assert_equal('[0,1,2,3]', json_encode(range(4)))
2983
Bram Moolenaar50985eb2020-01-27 22:09:39 +01002984 " len()
2985 call assert_equal(0, len(range(0)))
2986 call assert_equal(2, len(range(2)))
2987 call assert_equal(5, len(range(0, 12, 3)))
2988 call assert_equal(4, len(range(3, 0, -1)))
2989
2990 " list2str()
2991 call assert_equal('ABC', list2str(range(65, 67)))
Bram Moolenaard83392a2022-09-01 12:22:46 +01002992 call assert_fails('let s = list2str(5)', 'E1211:')
Bram Moolenaar50985eb2020-01-27 22:09:39 +01002993
2994 " lock()
2995 let thelist = range(5)
2996 lockvar thelist
2997
2998 " map()
2999 call assert_equal([0, 2, 4, 6, 8], map(range(5), 'v:val * 2'))
Bram Moolenaarf8ca03b2020-11-28 20:32:29 +01003000 call assert_equal([3, 5, 7, 9, 11], map(map(range(5), 'v:val * 2'), 'v:val + 3'))
3001 call assert_equal([2, 6], map(filter(range(5), 'v:val % 2'), 'v:val * 2'))
3002 call assert_equal([2, 4, 8], filter(map(range(5), 'v:val * 2'), 'v:val % 3'))
Bram Moolenaar50985eb2020-01-27 22:09:39 +01003003
3004 " match()
3005 call assert_equal(3, match(range(5), 3))
3006
3007 " matchaddpos()
3008 highlight MyGreenGroup ctermbg=green guibg=green
3009 call matchaddpos('MyGreenGroup', range(line('.'), line('.')))
3010
3011 " matchend()
3012 call assert_equal(4, matchend(range(5), '4'))
3013 call assert_equal(3, matchend(range(1, 5), '4'))
3014 call assert_equal(-1, matchend(range(1, 5), '42'))
3015
3016 " matchstrpos()
3017 call assert_equal(['4', 4, 0, 1], matchstrpos(range(5), '4'))
3018 call assert_equal(['4', 3, 0, 1], matchstrpos(range(1, 5), '4'))
3019 call assert_equal(['', -1, -1, -1], matchstrpos(range(1, 5), '42'))
3020
3021 " max() reverse()
3022 call assert_equal(0, max(range(0)))
3023 call assert_equal(0, max(range(10, 9)))
3024 call assert_equal(9, max(range(10)))
3025 call assert_equal(18, max(range(0, 20, 3)))
3026 call assert_equal(20, max(range(20, 0, -3)))
3027 call assert_equal(99999, max(range(100000)))
3028 call assert_equal(99999, max(range(99999, 0, -1)))
3029 call assert_equal(99999, max(reverse(range(100000))))
3030 call assert_equal(99999, max(reverse(range(99999, 0, -1))))
3031
3032 " min() reverse()
3033 call assert_equal(0, min(range(0)))
3034 call assert_equal(0, min(range(10, 9)))
3035 call assert_equal(5, min(range(5, 10)))
3036 call assert_equal(5, min(range(5, 10, 3)))
3037 call assert_equal(2, min(range(20, 0, -3)))
3038 call assert_equal(0, min(range(100000)))
3039 call assert_equal(0, min(range(99999, 0, -1)))
3040 call assert_equal(0, min(reverse(range(100000))))
3041 call assert_equal(0, min(reverse(range(99999, 0, -1))))
3042
3043 " remove()
3044 call assert_equal(1, remove(range(1, 10), 0))
3045 call assert_equal(2, remove(range(1, 10), 1))
3046 call assert_equal(9, remove(range(1, 10), 8))
3047 call assert_equal(10, remove(range(1, 10), 9))
3048 call assert_equal(10, remove(range(1, 10), -1))
3049 call assert_equal([3, 4, 5], remove(range(1, 10), 2, 4))
3050
3051 " repeat()
3052 call assert_equal([0, 1, 2, 0, 1, 2], repeat(range(3), 2))
3053 call assert_equal([0, 1, 2], repeat(range(3), 1))
3054 call assert_equal([], repeat(range(3), 0))
3055 call assert_equal([], repeat(range(5, 4), 2))
3056 call assert_equal([], repeat(range(5, 4), 0))
3057
3058 " reverse()
3059 call assert_equal([2, 1, 0], reverse(range(3)))
3060 call assert_equal([0, 1, 2, 3], reverse(range(3, 0, -1)))
3061 call assert_equal([9, 8, 7, 6, 5, 4, 3, 2, 1, 0], reverse(range(10)))
3062 call assert_equal([20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10], reverse(range(10, 20)))
3063 call assert_equal([16, 13, 10], reverse(range(10, 18, 3)))
3064 call assert_equal([19, 16, 13, 10], reverse(range(10, 19, 3)))
3065 call assert_equal([19, 16, 13, 10], reverse(range(10, 20, 3)))
3066 call assert_equal([11, 14, 17, 20], reverse(range(20, 10, -3)))
3067 call assert_equal([], reverse(range(0)))
3068
3069 " TODO: setpos()
3070 " new
3071 " call setline(1, repeat([''], bufnr('')))
3072 " call setline(bufnr('') + 1, repeat('x', bufnr('') * 2 + 6))
3073 " call setpos('x', range(bufnr(''), bufnr('') + 3))
3074 " bwipe!
3075
3076 " setreg()
3077 call setreg('a', range(3))
3078 call assert_equal("0\n1\n2\n", getreg('a'))
3079
Bram Moolenaarb0992022020-01-30 14:55:42 +01003080 " settagstack()
3081 call settagstack(1, #{items : range(4)})
Bram Moolenaar94255df2020-02-05 20:10:33 +01003082
Bram Moolenaarb0992022020-01-30 14:55:42 +01003083 " sign_define()
3084 call assert_fails("call sign_define(range(5))", "E715:")
3085 call assert_fails("call sign_placelist(range(5))", "E715:")
3086
3087 " sign_undefine()
3088 call assert_fails("call sign_undefine(range(5))", "E908:")
3089
3090 " sign_unplacelist()
3091 call assert_fails("call sign_unplacelist(range(5))", "E715:")
3092
Bram Moolenaar50985eb2020-01-27 22:09:39 +01003093 " sort()
3094 call assert_equal([0, 1, 2, 3, 4, 5], sort(range(5, 0, -1)))
3095
3096 " string()
3097 call assert_equal('[0, 1, 2, 3, 4]', string(range(5)))
3098
Bram Moolenaarb0992022020-01-30 14:55:42 +01003099 " taglist() with 'tagfunc'
3100 func TagFunc(pattern, flags, info)
3101 return range(10)
3102 endfunc
3103 set tagfunc=TagFunc
3104 call assert_fails("call taglist('asdf')", 'E987:')
3105 set tagfunc=
Bram Moolenaar94255df2020-02-05 20:10:33 +01003106
Bram Moolenaarb0992022020-01-30 14:55:42 +01003107 " term_start()
Bram Moolenaar705724e2020-01-31 21:13:42 +01003108 if has('terminal') && has('termguicolors')
Bram Moolenaarb0992022020-01-30 14:55:42 +01003109 call assert_fails('call term_start(range(3, 4))', 'E474:')
3110 let g:terminal_ansi_colors = range(16)
Bram Moolenaar94255df2020-02-05 20:10:33 +01003111 if has('win32')
3112 let cmd = "cmd /c dir"
3113 else
3114 let cmd = "ls"
3115 endif
LemonBoyb2b3acb2022-05-20 10:10:34 +01003116 call assert_fails('call term_start("' .. cmd .. '", #{term_finish: "close"'
3117 \ .. ', ansi_colors: range(16)})', 'E475:')
Bram Moolenaarb0855f52022-05-20 10:39:18 +01003118 unlet g:terminal_ansi_colors
Bram Moolenaarb0992022020-01-30 14:55:42 +01003119 endif
3120
Bram Moolenaar50985eb2020-01-27 22:09:39 +01003121 " type()
3122 call assert_equal(v:t_list, type(range(5)))
3123
3124 " uniq()
3125 call assert_equal([0, 1, 2, 3, 4], uniq(range(5)))
Bram Moolenaar0e05de42020-03-25 22:23:46 +01003126
3127 " errors
3128 call assert_fails('let x=range(2, 8, 0)', 'E726:')
3129 call assert_fails('let x=range(3, 1)', 'E727:')
3130 call assert_fails('let x=range(1, 3, -2)', 'E727:')
Bram Moolenaar99fa7212020-04-26 15:59:55 +02003131 call assert_fails('let x=range([])', 'E745:')
3132 call assert_fails('let x=range(1, [])', 'E745:')
3133 call assert_fails('let x=range(1, 4, [])', 'E745:')
Bram Moolenaar50985eb2020-01-27 22:09:39 +01003134endfunc
Bram Moolenaar4132eb52020-02-14 16:53:00 +01003135
Bram Moolenaarb3d83982022-01-27 19:59:47 +00003136func Test_garbagecollect_now_fails()
3137 let v:testing = 0
3138 call assert_fails('call test_garbagecollect_now()', 'E1142:')
3139 let v:testing = 1
3140endfunc
3141
Bram Moolenaar4132eb52020-02-14 16:53:00 +01003142func Test_echoraw()
3143 CheckScreendump
3144
3145 " Normally used for escape codes, but let's test with a CR.
3146 let lines =<< trim END
3147 call echoraw("hello\<CR>x")
3148 END
3149 call writefile(lines, 'XTest_echoraw')
3150 let buf = RunVimInTerminal('-S XTest_echoraw', {'rows': 5, 'cols': 40})
3151 call VerifyScreenDump(buf, 'Test_functions_echoraw', {})
3152
3153 " clean up
3154 call StopVimInTerminal(buf)
3155 call delete('XTest_echoraw')
3156endfunc
Bram Moolenaar8d588cc2020-02-25 21:47:45 +01003157
Bram Moolenaar92b83cc2020-04-25 15:24:44 +02003158" Test for echo highlighting
3159func Test_echohl()
3160 echohl Search
3161 echo 'Vim'
3162 call assert_equal('Vim', Screenline(&lines))
3163 " TODO: How to check the highlight group used by echohl?
3164 " ScreenAttrs() returns all zeros.
3165 echohl None
3166endfunc
3167
Bram Moolenaar0e05de42020-03-25 22:23:46 +01003168" Test for the eval() function
3169func Test_eval()
3170 call assert_fails("call eval('5 a')", 'E488:')
3171endfunc
3172
zeertzjqcdc83932022-09-12 13:38:41 +01003173" Test for the keytrans() function
3174func Test_keytrans()
3175 call assert_equal('<Space>', keytrans(' '))
3176 call assert_equal('<lt>', keytrans('<'))
3177 call assert_equal('<lt>Tab>', keytrans('<Tab>'))
3178 call assert_equal('<Tab>', keytrans("\<Tab>"))
3179 call assert_equal('<C-V>', keytrans("\<C-V>"))
3180 call assert_equal('<BS>', keytrans("\<BS>"))
3181 call assert_equal('<Home>', keytrans("\<Home>"))
3182 call assert_equal('<C-Home>', keytrans("\<C-Home>"))
3183 call assert_equal('<M-Home>', keytrans("\<M-Home>"))
3184 call assert_equal('<C-Space>', keytrans("\<C-Space>"))
3185 call assert_equal('<M-Space>', keytrans("\<*M-Space>"))
3186 call assert_equal('<M-x>', "\<*M-x>"->keytrans())
3187 call assert_equal('<C-I>', "\<*C-I>"->keytrans())
3188 call assert_equal('<S-3>', "\<*S-3>"->keytrans())
3189 call assert_equal('π', 'π'->keytrans())
3190 call assert_equal('<M-π>', "\<M-π>"->keytrans())
3191 call assert_equal('ě', 'ě'->keytrans())
3192 call assert_equal('<M-ě>', "\<M-ě>"->keytrans())
3193 call assert_equal('', ''->keytrans())
3194 call assert_equal('', test_null_string()->keytrans())
3195 call assert_fails('call keytrans(1)', 'E1174:')
3196 call assert_fails('call keytrans()', 'E119:')
3197endfunc
3198
Bram Moolenaar0e05de42020-03-25 22:23:46 +01003199" Test for the nr2char() function
3200func Test_nr2char()
3201 set encoding=latin1
3202 call assert_equal('@', nr2char(64))
3203 set encoding=utf8
3204 call assert_equal('a', nr2char(97, 1))
3205 call assert_equal('a', nr2char(97, 0))
Bram Moolenaarf7271e82020-05-24 18:45:07 +02003206
zeertzjqdb088872022-05-02 22:53:45 +01003207 call assert_equal("\x80\xfc\b" .. nr2char(0x100000), eval('"\<M-' .. nr2char(0x100000) .. '>"'))
3208 call assert_equal("\x80\xfc\b" .. nr2char(0x40000000), eval('"\<M-' .. nr2char(0x40000000) .. '>"'))
Bram Moolenaar0e05de42020-03-25 22:23:46 +01003209endfunc
3210
3211" Test for screenattr(), screenchar() and screenchars() functions
3212func Test_screen_functions()
3213 call assert_equal(-1, screenattr(-1, -1))
3214 call assert_equal(-1, screenchar(-1, -1))
3215 call assert_equal([], screenchars(-1, -1))
3216endfunc
3217
Bram Moolenaar08f41572020-04-20 16:50:00 +02003218" Test for getcurpos() and setpos()
3219func Test_getcurpos_setpos()
3220 new
3221 call setline(1, ['012345678', '012345678'])
3222 normal gg6l
3223 let sp = getcurpos()
3224 normal 0
3225 call setpos('.', sp)
3226 normal jyl
3227 call assert_equal('6', @")
Bram Moolenaar92b83cc2020-04-25 15:24:44 +02003228 call assert_equal(-1, setpos('.', test_null_list()))
3229 call assert_equal(-1, setpos('.', {}))
Bram Moolenaar99ca9c42020-09-22 21:55:41 +02003230
3231 let winid = win_getid()
3232 normal G$
3233 let pos = getcurpos()
3234 wincmd w
3235 call assert_equal(pos, getcurpos(winid))
3236
3237 wincmd w
Bram Moolenaar08f41572020-04-20 16:50:00 +02003238 close!
Bram Moolenaar99ca9c42020-09-22 21:55:41 +02003239
3240 call assert_equal(getcurpos(), getcurpos(0))
3241 call assert_equal([0, 0, 0, 0, 0], getcurpos(-1))
3242 call assert_equal([0, 0, 0, 0, 0], getcurpos(1999))
Bram Moolenaar08f41572020-04-20 16:50:00 +02003243endfunc
3244
Bram Moolenaar986b0fd2022-03-13 12:06:07 +00003245func Test_getmousepos()
3246 enew!
3247 call setline(1, "\t\t\t1234")
Bram Moolenaar533870a2022-03-13 15:52:44 +00003248 call test_setmouse(1, 1)
3249 call assert_equal(#{
3250 \ screenrow: 1,
3251 \ screencol: 1,
3252 \ winid: win_getid(),
3253 \ winrow: 1,
3254 \ wincol: 1,
3255 \ line: 1,
3256 \ column: 1,
3257 \ }, getmousepos())
Bram Moolenaar986b0fd2022-03-13 12:06:07 +00003258 call test_setmouse(1, 25)
3259 call assert_equal(#{
3260 \ screenrow: 1,
3261 \ screencol: 25,
3262 \ winid: win_getid(),
3263 \ winrow: 1,
3264 \ wincol: 25,
3265 \ line: 1,
Bram Moolenaar533870a2022-03-13 15:52:44 +00003266 \ column: 4,
Bram Moolenaar986b0fd2022-03-13 12:06:07 +00003267 \ }, getmousepos())
3268 call test_setmouse(1, 50)
3269 call assert_equal(#{
3270 \ screenrow: 1,
3271 \ screencol: 50,
3272 \ winid: win_getid(),
3273 \ winrow: 1,
3274 \ wincol: 50,
3275 \ line: 1,
Bram Moolenaar533870a2022-03-13 15:52:44 +00003276 \ column: 8,
Bram Moolenaar986b0fd2022-03-13 12:06:07 +00003277 \ }, getmousepos())
Sean Dewar10792fe2022-03-15 09:46:54 +00003278
3279 " If the mouse is positioned past the last buffer line, "line" and "column"
3280 " should act like it's positioned on the last buffer line.
3281 call test_setmouse(2, 25)
3282 call assert_equal(#{
3283 \ screenrow: 2,
3284 \ screencol: 25,
3285 \ winid: win_getid(),
3286 \ winrow: 2,
3287 \ wincol: 25,
3288 \ line: 1,
3289 \ column: 4,
3290 \ }, getmousepos())
3291 call test_setmouse(2, 50)
3292 call assert_equal(#{
3293 \ screenrow: 2,
3294 \ screencol: 50,
3295 \ winid: win_getid(),
3296 \ winrow: 2,
3297 \ wincol: 50,
3298 \ line: 1,
3299 \ column: 8,
3300 \ }, getmousepos())
Bram Moolenaar986b0fd2022-03-13 12:06:07 +00003301 bwipe!
3302endfunc
3303
Bram Moolenaar24dc19c2022-11-14 19:49:15 +00003304func Test_getmouseshape()
3305 CheckFeature mouseshape
3306
3307 call assert_equal('arrow', getmouseshape())
3308endfunc
3309
Bram Moolenaar92b83cc2020-04-25 15:24:44 +02003310" Test for glob()
3311func Test_glob()
3312 call assert_equal('', glob(test_null_string()))
3313 call assert_equal('', globpath(test_null_string(), test_null_string()))
Yegappan Lakshmanan46aa6f92021-05-19 17:15:04 +02003314 call assert_fails("let x = globpath(&rtp, 'syntax/c.vim', [])", 'E745:')
Bram Moolenaar1b04ce22020-08-21 22:46:11 +02003315
3316 call writefile([], 'Xglob1')
3317 call writefile([], 'XGLOB2')
3318 set wildignorecase
3319 " Sort output of glob() otherwise we end up with different
3320 " ordering depending on whether file system is case-sensitive.
3321 call assert_equal(['XGLOB2', 'Xglob1'], sort(glob('Xglob[12]', 0, 1)))
LemonBoya3157a42022-04-03 11:58:31 +01003322 " wildignorecase shall be applied even when the pattern contains no wildcards.
3323 call assert_equal('XGLOB2', glob('xglob2'))
Bram Moolenaar1b04ce22020-08-21 22:46:11 +02003324 set wildignorecase&
3325
3326 call delete('Xglob1')
3327 call delete('XGLOB2')
3328
3329 call assert_fails("call glob('*', 0, {})", 'E728:')
Bram Moolenaar92b83cc2020-04-25 15:24:44 +02003330endfunc
3331
3332" Test for browse()
3333func Test_browse()
3334 CheckFeature browse
3335 call assert_fails('call browse([], "open", "x", "a.c")', 'E745:')
3336endfunc
3337
3338" Test for browsedir()
3339func Test_browsedir()
3340 CheckFeature browse
3341 call assert_fails('call browsedir("open", [])', 'E730:')
3342endfunc
3343
Bram Moolenaarb47bed22021-04-14 17:06:43 +02003344func HasDefault(msg = 'msg')
3345 return a:msg
3346endfunc
3347
3348func Test_default_arg_value()
3349 call assert_equal('msg', HasDefault())
3350endfunc
3351
Yegappan Lakshmanan34fcb692021-05-25 20:14:00 +02003352" Test for gettext()
3353func Test_gettext()
Yegappan Lakshmanan8deb2b32022-09-02 15:15:27 +01003354 call assert_fails('call gettext(1)', 'E1174:')
Yegappan Lakshmanan34fcb692021-05-25 20:14:00 +02003355endfunc
3356
Bram Moolenaar3d9c4ee2021-05-31 22:15:26 +02003357func Test_builtin_check()
3358 call assert_fails('let g:["trim"] = {x -> " " .. x}', 'E704:')
3359 call assert_fails('let g:.trim = {x -> " " .. x}', 'E704:')
Bram Moolenaarb54abee2021-06-02 11:49:23 +02003360 call assert_fails('let l:["trim"] = {x -> " " .. x}', 'E704:')
3361 call assert_fails('let l:.trim = {x -> " " .. x}', 'E704:')
3362 let lines =<< trim END
3363 vim9script
Bram Moolenaar62b191c2022-02-12 20:34:50 +00003364 var trim = (x) => " " .. x
Bram Moolenaarb54abee2021-06-02 11:49:23 +02003365 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003366 call v9.CheckScriptFailure(lines, 'E704:')
Bram Moolenaar6f1d2aa2021-06-01 21:21:55 +02003367
3368 call assert_fails('call extend(g:, #{foo: { -> "foo" }})', 'E704:')
3369 let g:bar = 123
3370 call extend(g:, #{bar: { -> "foo" }}, "keep")
3371 call assert_fails('call extend(g:, #{bar: { -> "foo" }}, "force")', 'E704:')
zeertzjq91c75d12022-11-05 20:21:58 +00003372 unlet g:bar
3373
3374 call assert_fails('call extend(l:, #{foo: { -> "foo" }})', 'E704:')
3375 let bar = 123
3376 call extend(l:, #{bar: { -> "foo" }}, "keep")
3377 call assert_fails('call extend(l:, #{bar: { -> "foo" }}, "force")', 'E704:')
3378 unlet bar
3379
3380 call assert_fails('call extend(g:, #{foo: function("extend")})', 'E704:')
3381 let g:bar = 123
3382 call extend(g:, #{bar: function("extend")}, "keep")
3383 call assert_fails('call extend(g:, #{bar: function("extend")}, "force")', 'E704:')
3384 unlet g:bar
3385
3386 call assert_fails('call extend(l:, #{foo: function("extend")})', 'E704:')
3387 let bar = 123
3388 call extend(l:, #{bar: function("extend")}, "keep")
3389 call assert_fails('call extend(l:, #{bar: function("extend")}, "force")', 'E704:')
3390 unlet bar
Bram Moolenaar3d9c4ee2021-05-31 22:15:26 +02003391endfunc
3392
Bram Moolenaarc4ec3382021-12-09 16:40:18 +00003393func Test_funcref_to_string()
3394 let Fn = funcref('g:Test_funcref_to_string')
3395 call assert_equal("function('g:Test_funcref_to_string')", string(Fn))
3396endfunc
3397
LemonBoydca1d402022-04-28 15:26:33 +01003398" Test for isabsolutepath()
3399func Test_isabsolutepath()
3400 call assert_false(isabsolutepath(''))
3401 call assert_false(isabsolutepath('.'))
3402 call assert_false(isabsolutepath('../Foo'))
3403 call assert_false(isabsolutepath('Foo/'))
3404 if has('win32')
3405 call assert_true(isabsolutepath('A:\'))
3406 call assert_true(isabsolutepath('A:\Foo'))
3407 call assert_true(isabsolutepath('A:/Foo'))
3408 call assert_false(isabsolutepath('A:Foo'))
3409 call assert_false(isabsolutepath('\Windows'))
3410 call assert_true(isabsolutepath('\\Server2\Share\Test\Foo.txt'))
3411 else
3412 call assert_true(isabsolutepath('/'))
3413 call assert_true(isabsolutepath('/usr/share/'))
3414 endif
3415endfunc
Bram Moolenaar3d9c4ee2021-05-31 22:15:26 +02003416
Yasuhiro Matsumoto05cf63e2022-05-03 11:02:28 +01003417" Test for exepath()
3418func Test_exepath()
3419 if has('win32')
3420 call assert_notequal(exepath('cmd'), '')
3421
3422 let oldNoDefaultCurrentDirectoryInExePath = $NoDefaultCurrentDirectoryInExePath
3423 call writefile(['@echo off', 'echo Evil'], 'vim-test-evil.bat')
3424 let $NoDefaultCurrentDirectoryInExePath = ''
3425 call assert_notequal(exepath("vim-test-evil.bat"), '')
3426 let $NoDefaultCurrentDirectoryInExePath = '1'
3427 call assert_equal(exepath("vim-test-evil.bat"), '')
3428 let $NoDefaultCurrentDirectoryInExePath = oldNoDefaultCurrentDirectoryInExePath
3429 call delete('vim-test-evil.bat')
3430 else
3431 call assert_notequal(exepath('sh'), '')
3432 endif
3433endfunc
3434
LemonBoy0f7a3e12022-05-26 12:10:37 +01003435" Test for virtcol()
3436func Test_virtcol()
3437 enew!
3438 call setline(1, "the\tquick\tbrown\tfox")
3439 norm! 4|
3440 call assert_equal(8, virtcol('.'))
3441 call assert_equal(8, virtcol('.', v:false))
3442 call assert_equal([4, 8], virtcol('.', v:true))
3443 bwipe!
3444endfunc
3445
Bram Moolenaar398a26f2022-11-13 22:13:33 +00003446func Test_delfunc_while_listing()
3447 CheckRunVimInTerminal
3448
3449 let lines =<< trim END
3450 set nocompatible
3451 for i in range(1, 999)
3452 exe 'func ' .. 'MyFunc' .. i .. '()'
3453 endfunc
3454 endfor
3455 au CmdlineLeave : call timer_start(0, {-> execute('delfunc MyFunc622')})
3456 END
3457 call writefile(lines, 'Xfunctionclear', 'D')
3458 let buf = RunVimInTerminal('-S Xfunctionclear', {'rows': 12})
3459
3460 " This was using freed memory. The height of the terminal must be so that
3461 " the next function to be listed with "j" is the one that is deleted in the
3462 " timer callback, tricky!
3463 call term_sendkeys(buf, ":func /MyFunc\<CR>")
3464 call TermWait(buf, 50)
3465 call term_sendkeys(buf, "j")
3466 call TermWait(buf, 50)
3467 call term_sendkeys(buf, "\<CR>")
3468
3469 call StopVimInTerminal(buf)
3470endfunc
3471
Bram Moolenaar8d588cc2020-02-25 21:47:45 +01003472" vim: shiftwidth=2 sts=2 expandtab