Mercurial > vim
annotate src/testdir/test87.in @ 4551:f0c37f5cf4ea v7.3.1023
updated for version 7.3.1023
Problem: Searching for composing char only and using \Z has different
results.
Solution: Make it match the composing char, matching everything is not
useful.
author | Bram Moolenaar <bram@vim.org> |
---|---|
date | Sun, 26 May 2013 15:14:55 +0200 |
parents | ce94a870b59b |
children | fa39483a1363 |
rev | line source |
---|---|
3618 | 1 Tests for various python features. vim: set ft=vim : |
2 | |
3 STARTTEST | |
4 :so small.vim | |
5 :if !has('python3') | e! test.ok | wq! test.out | endif | |
4425 | 6 :lang C |
3618 | 7 :py3 import vim |
8 :fun Test() | |
9 :let l = [] | |
10 :py3 l=vim.bindeval('l') | |
11 :py3 f=vim.bindeval('function("strlen")') | |
12 :" Extending List directly with different types | |
13 :py3 l+=[1, "as'd", [1, 2, f, {'a': 1}]] | |
14 :$put =string(l) | |
15 :$put =string(l[-1]) | |
16 :try | |
17 : $put =string(l[-4]) | |
18 :catch | |
19 : $put =v:exception[:13] | |
20 :endtry | |
21 :" List assignment | |
22 :py3 l[0]=0 | |
23 :$put =string(l) | |
24 :py3 l[-2]=f | |
25 :$put =string(l) | |
26 :" | |
27 :" Extending Dictionary directly with different types | |
28 :let d = {} | |
29 :py3 d=vim.bindeval('d') | |
30 :py3 d['1']='asd' | |
31 :py3 d['b']=[1, 2, f] | |
32 :py3 d['-1']={'a': 1} | |
33 :let dkeys = [] | |
34 :py3 dk=vim.bindeval('dkeys') | |
35 :py3 dkeys=d.keys() | |
36 :py3 dkeys.sort() | |
37 :py3 dk+=dkeys | |
38 :$put =string(dkeys) | |
39 :for [key, val] in sort(items(d)) | |
40 : $put =string(key) . ' : ' . string(val) | |
41 : unlet key val | |
42 :endfor | |
43 :" | |
44 :" removing items with del | |
45 :py3 del l[2] | |
46 :$put =string(l) | |
47 :let l = range(8) | |
48 :py3 l=vim.bindeval('l') | |
49 :try | |
50 : py3 del l[:3] | |
51 : py3 del l[1:] | |
52 :catch | |
53 : $put =v:exception | |
54 :endtry | |
55 :$put =string(l) | |
56 :" | |
57 :py3 del d['-1'] | |
58 :$put =string(d) | |
59 :" | |
60 :" removing items out of range: silently skip items that don't exist | |
61 :let l = [0, 1, 2, 3] | |
62 :py3 l=vim.bindeval('l') | |
63 :" The following two ranges delete nothing as they match empty list: | |
64 :py3 del l[2:1] | |
65 :$put =string(l) | |
66 :py3 del l[2:2] | |
67 :$put =string(l) | |
68 :py3 del l[2:3] | |
69 :$put =string(l) | |
70 :let l = [0, 1, 2, 3] | |
71 :py3 l=vim.bindeval('l') | |
72 :py3 del l[2:4] | |
73 :$put =string(l) | |
74 :let l = [0, 1, 2, 3] | |
75 :py3 l=vim.bindeval('l') | |
76 :py3 del l[2:5] | |
77 :$put =string(l) | |
78 :let l = [0, 1, 2, 3] | |
79 :py3 l=vim.bindeval('l') | |
80 :py3 del l[2:6] | |
81 :$put =string(l) | |
82 :let l = [0, 1, 2, 3] | |
83 :py3 l=vim.bindeval('l') | |
84 :" The following two ranges delete nothing as they match empty list: | |
85 :py3 del l[-1:2] | |
86 :$put =string(l) | |
87 :py3 del l[-2:2] | |
88 :$put =string(l) | |
89 :py3 del l[-3:2] | |
90 :$put =string(l) | |
91 :let l = [0, 1, 2, 3] | |
92 :py3 l=vim.bindeval('l') | |
93 :py3 del l[-4:2] | |
94 :$put =string(l) | |
95 :let l = [0, 1, 2, 3] | |
96 :py3 l=vim.bindeval('l') | |
97 :py3 del l[-5:2] | |
98 :$put =string(l) | |
99 :let l = [0, 1, 2, 3] | |
100 :py3 l=vim.bindeval('l') | |
101 :py3 del l[-6:2] | |
102 :$put =string(l) | |
103 :" | |
104 :" Slice assignment to a list | |
105 :let l = [0, 1, 2, 3] | |
106 :py3 l=vim.bindeval('l') | |
107 :py3 l[0:0]=['a'] | |
108 :$put =string(l) | |
109 :let l = [0, 1, 2, 3] | |
110 :py3 l=vim.bindeval('l') | |
111 :py3 l[1:2]=['b'] | |
112 :$put =string(l) | |
113 :let l = [0, 1, 2, 3] | |
114 :py3 l=vim.bindeval('l') | |
115 :py3 l[2:4]=['c'] | |
116 :$put =string(l) | |
117 :let l = [0, 1, 2, 3] | |
118 :py3 l=vim.bindeval('l') | |
119 :py3 l[4:4]=['d'] | |
120 :$put =string(l) | |
121 :let l = [0, 1, 2, 3] | |
122 :py3 l=vim.bindeval('l') | |
123 :py3 l[-1:2]=['e'] | |
124 :$put =string(l) | |
125 :let l = [0, 1, 2, 3] | |
126 :py3 l=vim.bindeval('l') | |
127 :py3 l[-10:2]=['f'] | |
128 :$put =string(l) | |
129 :let l = [0, 1, 2, 3] | |
130 :py3 l=vim.bindeval('l') | |
131 :py3 l[2:-10]=['g'] | |
132 :$put =string(l) | |
133 :let l = [] | |
134 :py3 l=vim.bindeval('l') | |
135 :py3 l[0:0]=['h'] | |
136 :$put =string(l) | |
137 :" | |
138 :" Locked variables | |
139 :let l = [0, 1, 2, 3] | |
140 :py3 l=vim.bindeval('l') | |
141 :lockvar! l | |
142 :py3 l[2]='i' | |
143 :$put =string(l) | |
144 :unlockvar! l | |
145 :" | |
146 :" Function calls | |
147 :function New(...) | |
148 :return ['NewStart']+a:000+['NewEnd'] | |
149 :endfunction | |
150 :function DictNew(...) dict | |
151 :return ['DictNewStart']+a:000+['DictNewEnd', self] | |
152 :endfunction | |
153 :let l=[function('New'), function('DictNew')] | |
154 :py3 l=vim.bindeval('l') | |
155 :py3 l.extend(list(l[0](1, 2, 3))) | |
156 :$put =string(l) | |
157 :py3 l.extend(list(l[1](1, 2, 3, self={'a': 'b'}))) | |
158 :$put =string(l) | |
159 :py3 l+=[l[0].name] | |
160 :$put =string(l) | |
161 :try | |
162 : py3 l[1](1, 2, 3) | |
163 :catch | |
164 : $put =v:exception[:13] | |
165 :endtry | |
166 :delfunction New | |
167 :try | |
168 : py3 l[0](1, 2, 3) | |
169 :catch | |
170 : $put =v:exception[:13] | |
171 :endtry | |
172 :if has('float') | |
173 : let l=[0.0] | |
174 : py3 l=vim.bindeval('l') | |
175 : py3 l.extend([0.0]) | |
176 : $put =string(l) | |
177 :else | |
178 : $put ='[0.0, 0.0]' | |
179 :endif | |
3802 | 180 :let messages=[] |
181 :py3 <<EOF | |
182 d=vim.bindeval('{}') | |
183 m=vim.bindeval('messages') | |
184 try: | |
185 d['abc'] | |
186 except Exception as e: | |
187 m.extend([e.__class__.__name__]) | |
188 | |
189 try: | |
190 d['abc']="\0" | |
191 except Exception as e: | |
192 m.extend([e.__class__.__name__]) | |
193 | |
194 try: | |
195 d['abc']=vim | |
196 except Exception as e: | |
197 m.extend([e.__class__.__name__]) | |
198 | |
199 try: | |
200 d['']=1 | |
201 except Exception as e: | |
202 m.extend([e.__class__.__name__]) | |
203 | |
204 try: | |
205 d['a\0b']=1 | |
206 except Exception as e: | |
207 m.extend([e.__class__.__name__]) | |
208 | |
209 try: | |
210 d[b'a\0b']=1 | |
211 except Exception as e: | |
212 m.extend([e.__class__.__name__]) | |
213 EOF | |
214 :$put =messages | |
3828 | 215 :unlet messages |
216 :" locked and scope attributes | |
217 :let d={} | let dl={} | lockvar dl | |
218 :for s in split("d dl v: g:") | |
219 : let name=tr(s, ':', 's') | |
220 : execute 'py3 '.name.'=vim.bindeval("'.s.'")' | |
221 : let toput=s.' : '.join(map(['locked', 'scope'], 'v:val.":".py3eval(name.".".v:val)'), ';') | |
222 : $put =toput | |
223 :endfor | |
224 :silent! let d.abc=1 | |
225 :silent! let dl.abc=1 | |
226 :py3 d.locked=True | |
227 :py3 dl.locked=False | |
228 :silent! let d.def=1 | |
229 :silent! let dl.def=1 | |
230 :put ='d:'.string(d) | |
231 :put ='dl:'.string(dl) | |
232 :unlet d dl | |
233 : | |
234 :let l=[] | let ll=[] | lockvar ll | |
235 :for s in split("l ll") | |
236 : let name=tr(s, ':', 's') | |
237 : execute 'py3 '.name.'=vim.bindeval("'.s.'")' | |
238 : let toput=s.' : locked:'.py3eval(name.'.locked') | |
239 : $put =toput | |
240 :endfor | |
241 :silent! call extend(l, [0]) | |
242 :silent! call extend(ll, [0]) | |
243 :py3 l.locked=True | |
244 :py3 ll.locked=False | |
245 :silent! call extend(l, [1]) | |
246 :silent! call extend(ll, [1]) | |
247 :put ='l:'.string(l) | |
248 :put ='ll:'.string(ll) | |
249 :unlet l ll | |
3618 | 250 :" |
251 :" py3eval() | |
252 :let l=py3eval('[0, 1, 2]') | |
253 :$put =string(l) | |
254 :let d=py3eval('{"a": "b", "c": 1, "d": ["e"]}') | |
255 :$put =sort(items(d)) | |
256 :if has('float') | |
257 : let f=py3eval('0.0') | |
258 : $put =string(f) | |
259 :else | |
260 : $put ='0.0' | |
261 :endif | |
3802 | 262 :" Invalid values: |
263 :for e in ['"\0"', '{"\0": 1}', 'undefined_name', 'vim'] | |
264 : try | |
265 : let v=py3eval(e) | |
266 : catch | |
267 : let toput=e.":\t".v:exception[:13] | |
268 : $put =toput | |
269 : endtry | |
270 :endfor | |
4109 | 271 :" |
272 :" threading | |
273 :let l = [0] | |
274 :py3 l=vim.bindeval('l') | |
275 :py3 <<EOF | |
276 import threading | |
277 import time | |
278 | |
279 class T(threading.Thread): | |
280 def __init__(self): | |
281 threading.Thread.__init__(self) | |
282 self.t = 0 | |
283 self.running = True | |
284 | |
285 def run(self): | |
286 while self.running: | |
287 self.t += 1 | |
288 time.sleep(0.1) | |
289 | |
290 t = T() | |
291 t.start() | |
292 EOF | |
293 :sleep 1 | |
294 :py3 t.running = False | |
295 :py3 t.join() | |
296 :py3 l[0] = t.t > 8 # check if the background thread is working | |
297 :$put =string(l) | |
298 :" | |
299 :" settrace | |
300 :let l = [] | |
301 :py3 l=vim.bindeval('l') | |
302 :py3 <<EOF | |
303 import sys | |
304 | |
305 def traceit(frame, event, arg): | |
306 global l | |
307 if event == "line": | |
308 l += [frame.f_lineno] | |
309 return traceit | |
310 | |
311 def trace_main(): | |
312 for i in range(5): | |
313 pass | |
314 EOF | |
315 :py3 sys.settrace(traceit) | |
316 :py3 trace_main() | |
317 :py3 sys.settrace(None) | |
318 :$put =string(l) | |
4323 | 319 :" |
320 :" Vars | |
321 :let g:foo = 'bac' | |
322 :let w:abc = 'def' | |
323 :let b:baz = 'bar' | |
4413 | 324 :let t:bar = 'jkl' |
4323 | 325 :try |
326 : throw "Abc" | |
327 :catch | |
328 : put =py3eval('vim.vvars[''exception'']') | |
329 :endtry | |
330 :put =py3eval('vim.vars[''foo'']') | |
331 :put =py3eval('vim.current.window.vars[''abc'']') | |
332 :put =py3eval('vim.current.buffer.vars[''baz'']') | |
4413 | 333 :put =py3eval('vim.current.tabpage.vars[''bar'']') |
4350 | 334 :" |
335 :" Options | |
336 :" paste: boolean, global | |
337 :" previewheight number, global | |
338 :" operatorfunc: string, global | |
339 :" number: boolean, window-local | |
340 :" numberwidth: number, window-local | |
341 :" colorcolumn: string, window-local | |
342 :" statusline: string, window-local/global | |
343 :" autoindent: boolean, buffer-local | |
4427 | 344 :" shiftwidth: number, buffer-local |
4350 | 345 :" omnifunc: string, buffer-local |
346 :" preserveindent: boolean, buffer-local/global | |
347 :" path: string, buffer-local/global | |
348 :let g:bufs=[bufnr('%')] | |
349 :new | |
350 :let g:bufs+=[bufnr('%')] | |
351 :vnew | |
352 :let g:bufs+=[bufnr('%')] | |
353 :wincmd j | |
354 :vnew | |
355 :let g:bufs+=[bufnr('%')] | |
356 :wincmd l | |
357 :fun RecVars(opt) | |
358 : let gval =string(eval('&g:'.a:opt)) | |
359 : let wvals=join(map(range(1, 4), 'v:val.":".string(getwinvar(v:val, "&".a:opt))')) | |
360 : let bvals=join(map(copy(g:bufs), 'v:val.":".string(getbufvar(v:val, "&".a:opt))')) | |
361 : put =' G: '.gval | |
362 : put =' W: '.wvals | |
363 : put =' B: '.wvals | |
364 :endfun | |
365 py3 << EOF | |
366 def e(s, g=globals(), l=locals()): | |
367 try: | |
368 exec(s, g, l) | |
369 except Exception as e: | |
4498 | 370 vim.command('return ' + repr(e.__class__.__name__)) |
4350 | 371 |
372 def ev(s, g=globals(), l=locals()): | |
373 try: | |
374 return eval(s, g, l) | |
375 except Exception as e: | |
4498 | 376 vim.command('let exc=' + repr(e.__class__.__name__)) |
4350 | 377 return 0 |
378 EOF | |
379 :function E(s) | |
380 : python3 e(vim.eval('a:s')) | |
381 :endfunction | |
382 :function Ev(s) | |
4498 | 383 : let r=py3eval('ev(vim.eval("a:s"))') |
384 : if exists('exc') | |
385 : throw exc | |
386 : endif | |
387 : return r | |
4350 | 388 :endfunction |
389 :py3 gopts1=vim.options | |
390 :py3 wopts1=vim.windows[2].options | |
391 :py3 wopts2=vim.windows[0].options | |
392 :py3 wopts3=vim.windows[1].options | |
393 :py3 bopts1=vim.buffers[vim.bindeval("g:bufs")[2]].options | |
394 :py3 bopts2=vim.buffers[vim.bindeval("g:bufs")[1]].options | |
395 :py3 bopts3=vim.buffers[vim.bindeval("g:bufs")[0]].options | |
396 :let lst=[] | |
397 :let lst+=[['paste', 1, 0, 1, 2, 1, 1, 0 ]] | |
398 :let lst+=[['previewheight', 5, 1, 6, 'a', 0, 1, 0 ]] | |
399 :let lst+=[['operatorfunc', 'A', 'B', 'C', 2, 0, 1, 0 ]] | |
400 :let lst+=[['number', 0, 1, 1, 0, 1, 0, 1 ]] | |
401 :let lst+=[['numberwidth', 2, 3, 5, -100, 0, 0, 1 ]] | |
402 :let lst+=[['colorcolumn', '+1', '+2', '+3', 'abc', 0, 0, 1 ]] | |
403 :let lst+=[['statusline', '1', '2', '4', 0, 0, 1, 1 ]] | |
404 :let lst+=[['autoindent', 0, 1, 1, 2, 1, 0, 2 ]] | |
4427 | 405 :let lst+=[['shiftwidth', 0, 2, 1, 3, 0, 0, 2 ]] |
4350 | 406 :let lst+=[['omnifunc', 'A', 'B', 'C', 1, 0, 0, 2 ]] |
407 :let lst+=[['preserveindent', 0, 1, 1, 2, 1, 1, 2 ]] | |
408 :let lst+=[['path', '.,,', ',,', '.', 0, 0, 1, 2 ]] | |
409 :for [oname, oval1, oval2, oval3, invval, bool, global, local] in lst | |
410 : py3 oname=vim.eval('oname') | |
411 : py3 oval1=vim.bindeval('oval1') | |
412 : py3 oval2=vim.bindeval('oval2') | |
413 : py3 oval3=vim.bindeval('oval3') | |
414 : if invval is 0 || invval is 1 | |
415 : py3 invval=bool(vim.bindeval('invval')) | |
416 : else | |
417 : py3 invval=vim.bindeval('invval') | |
418 : endif | |
419 : if bool | |
420 : py3 oval1=bool(oval1) | |
421 : py3 oval2=bool(oval2) | |
422 : py3 oval3=bool(oval3) | |
423 : endif | |
424 : put ='>>> '.oname | |
425 : for v in ['gopts1', 'wopts1', 'bopts1'] | |
426 : try | |
427 : put =' p/'.v.': '.Ev('repr('.v.'['''.oname.'''])') | |
428 : catch | |
429 : put =' p/'.v.'! '.v:exception | |
430 : endtry | |
4498 | 431 : let r=E(v.'['''.oname.''']=invval') |
432 : if r isnot 0 | |
433 : put =' inv: '.string(invval).'! '.r | |
434 : endif | |
4350 | 435 : for vv in (v is# 'gopts1' ? [v] : [v, v[:-2].'2', v[:-2].'3']) |
436 : let val=substitute(vv, '^.opts', 'oval', '') | |
4498 | 437 : let r=E(vv.'['''.oname.''']='.val) |
438 : if r isnot 0 | |
439 : put =' '.vv.'! '.r | |
440 : endif | |
4350 | 441 : endfor |
442 : endfor | |
443 : call RecVars(oname) | |
444 : for v in ['wopts3', 'bopts3'] | |
4498 | 445 : let r=E('del '.v.'["'.oname.'"]') |
446 : if r isnot 0 | |
447 : put =' del '.v.'! '.r | |
448 : endif | |
4350 | 449 : endfor |
450 : call RecVars(oname) | |
451 :endfor | |
452 :only | |
4397 | 453 :for buf in g:bufs[1:] |
454 : execute 'bwipeout!' buf | |
455 :endfor | |
4389 | 456 :" |
457 :" Test buffer object | |
458 :vnew | |
459 :put ='First line' | |
460 :put ='Second line' | |
461 :put ='Third line' | |
462 :1 delete _ | |
463 :py3 b=vim.current.buffer | |
464 :wincmd w | |
465 :mark a | |
466 py3 << EOF | |
467 cb = vim.current.buffer | |
468 # Tests BufferAppend and BufferItem | |
469 cb.append(b[0]) | |
470 # Tests BufferSlice and BufferAssSlice | |
471 cb.append('abc') # Will be overwritten | |
472 cb[-1:] = b[:-2] | |
473 # Test BufferLength and BufferAssSlice | |
474 cb.append('def') # Will not be overwritten | |
475 cb[len(cb):] = b[:] | |
476 # Test BufferAssItem and BufferMark | |
477 cb.append('ghi') # Will be overwritten | |
478 cb[-1] = repr((len(cb) - cb.mark('a')[0], cb.mark('a')[1])) | |
479 # Test BufferRepr | |
480 cb.append(repr(cb) + repr(b)) | |
481 # Modify foreign buffer | |
482 b.append('foo') | |
483 b[0]='bar' | |
484 b[0:0]=['baz'] | |
485 vim.command('call append("$", getbufline(%i, 1, "$"))' % b.number) | |
486 # Test CheckBuffer | |
487 vim.command('bwipeout! ' + str(b.number)) | |
488 for expr in ('b[1]','b[:] = ["A", "B"]','b[:]','b.append("abc")'): | |
489 try: | |
490 exec(expr) | |
491 except vim.error: | |
492 pass | |
493 else: | |
494 # Usually a SEGV here | |
495 # Should not happen in any case | |
496 cb.append('No exception for ' + expr) | |
497 EOF | |
4397 | 498 :" |
499 :" Test vim.buffers object | |
500 :set hidden | |
501 :edit a | |
502 :buffer # | |
503 :edit b | |
504 :buffer # | |
505 :edit c | |
506 :buffer # | |
507 py3 << EOF | |
508 # Check GCing iterator that was not fully exhausted | |
509 i = iter(vim.buffers) | |
510 cb.append('i:' + str(next(i))) | |
511 # and also check creating more then one iterator at a time | |
512 i2 = iter(vim.buffers) | |
513 cb.append('i2:' + str(next(i2))) | |
514 cb.append('i:' + str(next(i))) | |
515 # The following should trigger GC and not cause any problems | |
516 del i | |
517 del i2 | |
518 i3 = iter(vim.buffers) | |
519 cb.append('i3:' + str(next(i3))) | |
520 del i3 | |
521 | |
522 prevnum = 0 | |
523 for b in vim.buffers: | |
524 # Check buffer order | |
525 if prevnum >= b.number: | |
526 cb.append('!!! Buffer numbers not in strictly ascending order') | |
527 # Check indexing: vim.buffers[number].number == number | |
528 cb.append(str(b.number) + ':' + repr(vim.buffers[b.number]) + '=' + repr(b)) | |
529 prevnum = b.number | |
530 | |
531 cb.append(str(len(vim.buffers))) | |
532 | |
533 bnums = list(map(lambda b: b.number, vim.buffers))[1:] | |
534 | |
535 # Test wiping out buffer with existing iterator | |
536 i4 = iter(vim.buffers) | |
537 cb.append('i4:' + str(next(i4))) | |
538 vim.command('bwipeout! ' + str(bnums.pop(0))) | |
539 try: | |
540 next(i4) | |
541 except vim.error: | |
542 pass | |
543 else: | |
544 cb.append('!!!! No vim.error') | |
545 i4 = iter(vim.buffers) | |
546 vim.command('bwipeout! ' + str(bnums.pop(-1))) | |
547 vim.command('bwipeout! ' + str(bnums.pop(-1))) | |
548 cb.append('i4:' + str(next(i4))) | |
549 try: | |
550 next(i4) | |
551 except StopIteration: | |
552 cb.append('StopIteration') | |
553 EOF | |
4413 | 554 :" |
555 :" Test vim.{tabpage,window}list and vim.{tabpage,window} objects | |
556 :tabnew 0 | |
557 :tabnew 1 | |
558 :vnew a.1 | |
559 :tabnew 2 | |
560 :vnew a.2 | |
561 :vnew b.2 | |
562 :vnew c.2 | |
563 py3 << EOF | |
4511
ce94a870b59b
updated for version 7.3.1003
Bram Moolenaar <bram@vim.org>
parents:
4498
diff
changeset
|
564 cb.append('Number of tabs: ' + str(len(vim.tabpages))) |
ce94a870b59b
updated for version 7.3.1003
Bram Moolenaar <bram@vim.org>
parents:
4498
diff
changeset
|
565 cb.append('Current tab pages:') |
ce94a870b59b
updated for version 7.3.1003
Bram Moolenaar <bram@vim.org>
parents:
4498
diff
changeset
|
566 |
4413 | 567 def W(w): |
568 if '(unknown)' in repr(w): | |
569 return '<window object (unknown)>' | |
570 else: | |
571 return repr(w) | |
4511
ce94a870b59b
updated for version 7.3.1003
Bram Moolenaar <bram@vim.org>
parents:
4498
diff
changeset
|
572 |
ce94a870b59b
updated for version 7.3.1003
Bram Moolenaar <bram@vim.org>
parents:
4498
diff
changeset
|
573 def Cursor(w, start=len(cb)): |
ce94a870b59b
updated for version 7.3.1003
Bram Moolenaar <bram@vim.org>
parents:
4498
diff
changeset
|
574 if w.buffer is cb: |
ce94a870b59b
updated for version 7.3.1003
Bram Moolenaar <bram@vim.org>
parents:
4498
diff
changeset
|
575 return repr((start - w.cursor[0], w.cursor[1])) |
ce94a870b59b
updated for version 7.3.1003
Bram Moolenaar <bram@vim.org>
parents:
4498
diff
changeset
|
576 else: |
ce94a870b59b
updated for version 7.3.1003
Bram Moolenaar <bram@vim.org>
parents:
4498
diff
changeset
|
577 return repr(w.cursor) |
ce94a870b59b
updated for version 7.3.1003
Bram Moolenaar <bram@vim.org>
parents:
4498
diff
changeset
|
578 |
4413 | 579 for t in vim.tabpages: |
580 cb.append(' ' + repr(t) + '(' + str(t.number) + ')' + ': ' + str(len(t.windows)) + ' windows, current is ' + W(t.window)) | |
581 cb.append(' Windows:') | |
582 for w in t.windows: | |
4511
ce94a870b59b
updated for version 7.3.1003
Bram Moolenaar <bram@vim.org>
parents:
4498
diff
changeset
|
583 cb.append(' ' + W(w) + '(' + str(w.number) + ')' + ': displays buffer ' + repr(w.buffer) + '; cursor is at ' + Cursor(w)) |
4413 | 584 # Other values depend on the size of the terminal, so they are checked partly: |
585 for attr in ('height', 'row', 'width', 'col'): | |
586 try: | |
587 aval = getattr(w, attr) | |
588 if type(aval) is not int: | |
589 raise TypeError | |
590 if aval < 0: | |
591 raise ValueError | |
592 except Exception as e: | |
593 cb.append('!!!!!! Error while getting attribute ' + attr + ': ' + e.__class__.__name__) | |
594 w.cursor = (len(w.buffer), 0) | |
595 cb.append('Number of windows in current tab page: ' + str(len(vim.windows))) | |
596 if list(vim.windows) != list(vim.current.tabpage.windows): | |
597 cb.append('!!!!!! Windows differ') | |
598 EOF | |
599 :" | |
600 :" Test vim.current | |
601 py3 << EOF | |
602 def H(o): | |
603 return repr(o) | |
604 cb.append('Current tab page: ' + repr(vim.current.tabpage)) | |
605 cb.append('Current window: ' + repr(vim.current.window) + ': ' + H(vim.current.window) + ' is ' + H(vim.current.tabpage.window)) | |
606 cb.append('Current buffer: ' + repr(vim.current.buffer) + ': ' + H(vim.current.buffer) + ' is ' + H(vim.current.window.buffer)+ ' is ' + H(vim.current.tabpage.window.buffer)) | |
607 # Assigning: fails | |
608 try: | |
609 vim.current.window = vim.tabpages[0].window | |
610 except ValueError: | |
611 cb.append('ValueError at assigning foreign tab window') | |
612 | |
613 for attr in ('window', 'tabpage', 'buffer'): | |
614 try: | |
615 setattr(vim.current, attr, None) | |
616 except TypeError: | |
617 cb.append('Type error at assigning None to vim.current.' + attr) | |
618 | |
619 # Assigning: success | |
620 vim.current.tabpage = vim.tabpages[-2] | |
621 vim.current.buffer = cb | |
622 vim.current.window = vim.windows[0] | |
623 vim.current.window.cursor = (len(vim.current.buffer), 0) | |
624 cb.append('Current tab page: ' + repr(vim.current.tabpage)) | |
625 cb.append('Current window: ' + repr(vim.current.window)) | |
626 cb.append('Current buffer: ' + repr(vim.current.buffer)) | |
627 cb.append('Current line: ' + repr(vim.current.line)) | |
628 for b in vim.buffers: | |
629 if b is not cb: | |
630 vim.command('bwipeout! ' + str(b.number)) | |
631 EOF | |
632 :tabonly! | |
633 :only! | |
4496 | 634 :" |
635 :" Test types | |
636 py3 << EOF | |
637 for expr, attr in ( | |
638 ('vim.vars', 'Dictionary'), | |
639 ('vim.options', 'Options'), | |
640 ('vim.bindeval("{}")', 'Dictionary'), | |
641 ('vim.bindeval("[]")', 'List'), | |
642 ('vim.bindeval("function(\'tr\')")', 'Function'), | |
643 ('vim.current.buffer', 'Buffer'), | |
644 ('vim.current.range', 'Range'), | |
645 ('vim.current.window', 'Window'), | |
646 ('vim.current.tabpage', 'TabPage'), | |
647 ): | |
648 cb.append(expr + ':' + attr + ':' + repr(type(eval(expr)) is getattr(vim, attr))) | |
649 EOF | |
4498 | 650 :" |
651 :" Test exceptions | |
652 :fun Exe(e) | |
653 : execute a:e | |
654 :endfun | |
655 py3 << EOF | |
656 def ee(expr, g=globals(), l=locals()): | |
657 try: | |
658 exec(expr, g, l) | |
659 except Exception as e: | |
660 cb.append(repr((e.__class__, e))) | |
661 Exe = vim.bindeval('function("Exe")') | |
662 ee('vim.command("throw \'abc\'")') | |
663 ee('Exe("throw \'def\'")') | |
664 ee('vim.eval("Exe(\'throw \'\'ghi\'\'\')")') | |
665 ee('vim.eval("Exe(\'echoerr \'\'jkl\'\'\')")') | |
666 ee('vim.eval("Exe(\'xxx_non_existent_command_xxx\')")') | |
667 ee('vim.bindeval("Exe(\'xxx_non_existent_command_xxx\')")') | |
668 EOF | |
3618 | 669 :endfun |
670 :" | |
671 :call Test() | |
672 :" | |
673 :delfunc Test | |
674 :call garbagecollect(1) | |
675 :" | |
676 :/^start:/,$wq! test.out | |
4397 | 677 :call getchar() |
3618 | 678 ENDTEST |
679 | |
680 start: |