1" Tests for the various 'formatoptions' settings
2
3source check.vim
4
5func Test_text_format()
6  enew!
7
8  setl noai tw=2 fo=t
9  call append('$', [
10	      \ '{',
11	      \ '    ',
12	      \ '',
13	      \ '}'])
14  exe "normal /^{/+1\n0"
15  normal gRa b
16  let lnum = line('.')
17  call assert_equal([
18	      \ 'a',
19	      \ 'b'], getline(lnum - 1, lnum))
20
21  normal ggdG
22  setl ai tw=2 fo=tw
23  call append('$', [
24	      \ '{',
25	      \ 'a  b  ',
26	      \ '',
27	      \ 'a    ',
28	      \ '}'])
29  exe "normal /^{/+1\n0"
30  normal gqgqjjllab
31  let lnum = line('.')
32  call assert_equal([
33	      \ 'a  ',
34	      \ 'b  ',
35	      \ '',
36	      \ 'a  ',
37	      \ 'b'], getline(lnum - 4, lnum))
38
39  normal ggdG
40  setl tw=3 fo=t
41  call append('$', [
42	      \ '{',
43	      \ "a \<C-A>",
44	      \ '}'])
45  exe "normal /^{/+1\n0"
46  exe "normal gqgqo\na \<C-V>\<C-A>"
47  let lnum = line('.')
48  call assert_equal([
49	      \ 'a',
50	      \ "\<C-A>",
51	      \ '',
52	      \ 'a',
53	      \ "\<C-A>"], getline(lnum - 4, lnum))
54
55  normal ggdG
56  setl tw=2 fo=tcq1 comments=:#
57  call append('$', [
58	      \ '{',
59	      \ 'a b',
60	      \ '#a b',
61	      \ '}'])
62  exe "normal /^{/+1\n0"
63  exe "normal gqgqjgqgqo\na b\n#a b"
64  let lnum = line('.')
65  call assert_equal([
66	      \ 'a b',
67	      \ '#a b',
68	      \ '',
69	      \ 'a b',
70	      \ '#a b'], getline(lnum - 4, lnum))
71
72  normal ggdG
73  setl tw=5 fo=tcn comments=:#
74  call append('$', [
75	      \ '{',
76	      \ '  1 a',
77	      \ '# 1 a',
78	      \ '}'])
79  exe "normal /^{/+1\n0"
80  exe "normal A b\<Esc>jA b"
81  let lnum = line('.')
82  call assert_equal([
83	      \ '  1 a',
84	      \ '    b',
85	      \ '# 1 a',
86	      \ '#   b'], getline(lnum - 3, lnum))
87
88  normal ggdG
89  setl tw=5 fo=t2a si
90  call append('$', [
91	      \ '{',
92	      \ '',
93	      \ '  x a',
94	      \ '  b',
95	      \ ' c',
96	      \ '',
97	      \ '}'])
98  exe "normal /^{/+3\n0"
99  exe "normal i  \<Esc>A_"
100  let lnum = line('.')
101  call assert_equal([
102	      \ '',
103	      \ '  x a',
104	      \ '    b_',
105	      \ '    c',
106	      \ ''], getline(lnum - 2, lnum + 2))
107
108  normal ggdG
109  setl tw=5 fo=qn comments=:#
110  call append('$', [
111	      \ '{',
112	      \ '# 1 a b',
113	      \ '}'])
114  exe "normal /^{/+1\n5|"
115  normal gwap
116  call assert_equal(5, col('.'))
117  let lnum = line('.')
118  call assert_equal([
119	      \ '# 1 a',
120	      \ '#   b'], getline(lnum, lnum + 1))
121
122  normal ggdG
123  setl tw=5 fo=q2 comments=:#
124  call append('$', [
125	      \ '{',
126	      \ '# x',
127	      \ '#   a b',
128	      \ '}'])
129  exe "normal /^{/+1\n0"
130  normal gwap
131  let lnum = line('.')
132  call assert_equal([
133	      \ '# x a',
134	      \ '#   b'], getline(lnum, lnum + 1))
135
136  normal ggdG
137  setl tw& fo=a
138  call append('$', [
139	      \ '{',
140	      \ '   1aa',
141	      \ '   2bb',
142	      \ '}'])
143  exe "normal /^{/+2\n0"
144  normal I^^
145  call assert_equal('{ 1aa ^^2bb }', getline('.'))
146
147  normal ggdG
148  setl tw=20 fo=an12wcq comments=s1:/*,mb:*,ex:*/
149  call append('$', [
150	      \ '/* abc def ghi jkl ',
151	      \ ' *    mno pqr stu',
152	      \ ' */'])
153  exe "normal /mno pqr/\n"
154  normal A vwx yz
155  let lnum = line('.')
156  call assert_equal([
157	      \ ' *    mno pqr stu ',
158	      \ ' *    vwx yz',
159	      \ ' */'], getline(lnum - 1, lnum + 1))
160
161  normal ggdG
162  setl tw=12 fo=tqnc comments=:#
163  call setline('.', '# 1 xxxxx')
164  normal A foobar
165  call assert_equal([
166	      \ '# 1 xxxxx',
167	      \ '#   foobar'], getline(1, 2))
168
169  " Test the 'p' flag for 'formatoptions'
170  " First test without the flag: that it will break "Mr. Feynman" at the space
171  normal ggdG
172  setl tw=28 fo=tcq
173  call setline('.', 'Surely you''re joking, Mr. Feynman!')
174  normal gqq
175  call assert_equal([
176              \ 'Surely you''re joking, Mr.',
177              \ 'Feynman!'], getline(1, 2))
178  " Now test with the flag: that it will push the name with the title onto the
179  " next line
180  normal ggdG
181  setl fo+=p
182  call setline('.', 'Surely you''re joking, Mr. Feynman!')
183  normal gqq
184  call assert_equal([
185              \ 'Surely you''re joking,',
186              \ 'Mr. Feynman!'], getline(1, 2))
187  " Ensure that it will still break if two spaces are entered
188  normal ggdG
189  call setline('.', 'Surely you''re joking, Mr.  Feynman!')
190  normal gqq
191  call assert_equal([
192              \ 'Surely you''re joking, Mr.',
193              \ 'Feynman!'], getline(1, 2))
194
195  setl ai& tw& fo& si& comments&
196  enew!
197endfunc
198
199" Tests for :right, :center and :left on text with embedded TAB.
200func Test_format_align()
201  enew!
202  set tw=65
203
204  " :left alignment
205  call append(0, [
206	      \ "	test for :left",
207	      \ "	  a		a",
208	      \ "	    fa		a",
209	      \ "	  dfa		a",
210	      \ "	        sdfa		a",
211	      \ "	  asdfa		a",
212	      \ "	        xasdfa		a",
213	      \ "asxxdfa		a",
214	      \ ])
215  %left
216  call assert_equal([
217	      \ "test for :left",
218	      \ "a		a",
219	      \ "fa		a",
220	      \ "dfa		a",
221	      \ "sdfa		a",
222	      \ "asdfa		a",
223	      \ "xasdfa		a",
224	      \ "asxxdfa		a",
225	      \ ""
226	      \ ], getline(1, '$'))
227  enew!
228
229  " :center alignment
230  call append(0, [
231	      \ "	test for :center",
232	      \ "	  a		a",
233	      \ "	    fa		afd asdf",
234	      \ "	  dfa		a",
235	      \ "	        sdfa		afd asdf",
236	      \ "	  asdfa		a",
237	      \ "	        xasdfa		asdfasdfasdfasdfasdf",
238	      \ "asxxdfa		a"
239	      \ ])
240  %center
241  call assert_equal([
242	      \ "			test for :center",
243	      \ "			 a		a",
244	      \ "		      fa		afd asdf",
245	      \ "			 dfa		a",
246	      \ "		    sdfa		afd asdf",
247	      \ "			 asdfa		a",
248	      \ "	      xasdfa		asdfasdfasdfasdfasdf",
249	      \ "			asxxdfa		a",
250	      \ ""
251	      \ ], getline(1, '$'))
252  enew!
253
254  " :right alignment
255  call append(0, [
256	      \ "	test for :right",
257	      \ "	a		a",
258	      \ "	fa		a",
259	      \ "	dfa		a",
260	      \ "	sdfa		a",
261	      \ "	asdfa		a",
262	      \ "	xasdfa		a",
263	      \ "	asxxdfa		a",
264	      \ "	asxa;ofa		a",
265	      \ "	asdfaqwer		a",
266	      \ "	a		ax",
267	      \ "	fa		ax",
268	      \ "	dfa		ax",
269	      \ "	sdfa		ax",
270	      \ "	asdfa		ax",
271	      \ "	xasdfa		ax",
272	      \ "	asxxdfa		ax",
273	      \ "	asxa;ofa		ax",
274	      \ "	asdfaqwer		ax",
275	      \ "	a		axx",
276	      \ "	fa		axx",
277	      \ "	dfa		axx",
278	      \ "	sdfa		axx",
279	      \ "	asdfa		axx",
280	      \ "	xasdfa		axx",
281	      \ "	asxxdfa		axx",
282	      \ "	asxa;ofa		axx",
283	      \ "	asdfaqwer		axx",
284	      \ "	a		axxx",
285	      \ "	fa		axxx",
286	      \ "	dfa		axxx",
287	      \ "	sdfa		axxx",
288	      \ "	asdfa		axxx",
289	      \ "	xasdfa		axxx",
290	      \ "	asxxdfa		axxx",
291	      \ "	asxa;ofa		axxx",
292	      \ "	asdfaqwer		axxx",
293	      \ "	a		axxxo",
294	      \ "	fa		axxxo",
295	      \ "	dfa		axxxo",
296	      \ "	sdfa		axxxo",
297	      \ "	asdfa		axxxo",
298	      \ "	xasdfa		axxxo",
299	      \ "	asxxdfa		axxxo",
300	      \ "	asxa;ofa		axxxo",
301	      \ "	asdfaqwer		axxxo",
302	      \ "	a		axxxoi",
303	      \ "	fa		axxxoi",
304	      \ "	dfa		axxxoi",
305	      \ "	sdfa		axxxoi",
306	      \ "	asdfa		axxxoi",
307	      \ "	xasdfa		axxxoi",
308	      \ "	asxxdfa		axxxoi",
309	      \ "	asxa;ofa		axxxoi",
310	      \ "	asdfaqwer		axxxoi",
311	      \ "	a		axxxoik",
312	      \ "	fa		axxxoik",
313	      \ "	dfa		axxxoik",
314	      \ "	sdfa		axxxoik",
315	      \ "	asdfa		axxxoik",
316	      \ "	xasdfa		axxxoik",
317	      \ "	asxxdfa		axxxoik",
318	      \ "	asxa;ofa		axxxoik",
319	      \ "	asdfaqwer		axxxoik",
320	      \ "	a		axxxoike",
321	      \ "	fa		axxxoike",
322	      \ "	dfa		axxxoike",
323	      \ "	sdfa		axxxoike",
324	      \ "	asdfa		axxxoike",
325	      \ "	xasdfa		axxxoike",
326	      \ "	asxxdfa		axxxoike",
327	      \ "	asxa;ofa		axxxoike",
328	      \ "	asdfaqwer		axxxoike",
329	      \ "	a		axxxoikey",
330	      \ "	fa		axxxoikey",
331	      \ "	dfa		axxxoikey",
332	      \ "	sdfa		axxxoikey",
333	      \ "	asdfa		axxxoikey",
334	      \ "	xasdfa		axxxoikey",
335	      \ "	asxxdfa		axxxoikey",
336	      \ "	asxa;ofa		axxxoikey",
337	      \ "	asdfaqwer		axxxoikey",
338	      \ ])
339  %right
340  call assert_equal([
341	      \ "\t\t\t\t		  test for :right",
342	      \ "\t\t\t\t		      a		a",
343	      \ "\t\t\t\t		     fa		a",
344	      \ "\t\t\t\t		    dfa		a",
345	      \ "\t\t\t\t		   sdfa		a",
346	      \ "\t\t\t\t		  asdfa		a",
347	      \ "\t\t\t\t		 xasdfa		a",
348	      \ "\t\t\t\t		asxxdfa		a",
349	      \ "\t\t\t\t	       asxa;ofa		a",
350	      \ "\t\t\t\t	      asdfaqwer		a",
351	      \ "\t\t\t\t	      a		ax",
352	      \ "\t\t\t\t	     fa		ax",
353	      \ "\t\t\t\t	    dfa		ax",
354	      \ "\t\t\t\t	   sdfa		ax",
355	      \ "\t\t\t\t	  asdfa		ax",
356	      \ "\t\t\t\t	 xasdfa		ax",
357	      \ "\t\t\t\t	asxxdfa		ax",
358	      \ "\t\t\t\t       asxa;ofa		ax",
359	      \ "\t\t\t\t      asdfaqwer		ax",
360	      \ "\t\t\t\t	      a		axx",
361	      \ "\t\t\t\t	     fa		axx",
362	      \ "\t\t\t\t	    dfa		axx",
363	      \ "\t\t\t\t	   sdfa		axx",
364	      \ "\t\t\t\t	  asdfa		axx",
365	      \ "\t\t\t\t	 xasdfa		axx",
366	      \ "\t\t\t\t	asxxdfa		axx",
367	      \ "\t\t\t\t       asxa;ofa		axx",
368	      \ "\t\t\t\t      asdfaqwer		axx",
369	      \ "\t\t\t\t	      a		axxx",
370	      \ "\t\t\t\t	     fa		axxx",
371	      \ "\t\t\t\t	    dfa		axxx",
372	      \ "\t\t\t\t	   sdfa		axxx",
373	      \ "\t\t\t\t	  asdfa		axxx",
374	      \ "\t\t\t\t	 xasdfa		axxx",
375	      \ "\t\t\t\t	asxxdfa		axxx",
376	      \ "\t\t\t\t       asxa;ofa		axxx",
377	      \ "\t\t\t\t      asdfaqwer		axxx",
378	      \ "\t\t\t\t	      a		axxxo",
379	      \ "\t\t\t\t	     fa		axxxo",
380	      \ "\t\t\t\t	    dfa		axxxo",
381	      \ "\t\t\t\t	   sdfa		axxxo",
382	      \ "\t\t\t\t	  asdfa		axxxo",
383	      \ "\t\t\t\t	 xasdfa		axxxo",
384	      \ "\t\t\t\t	asxxdfa		axxxo",
385	      \ "\t\t\t\t       asxa;ofa		axxxo",
386	      \ "\t\t\t\t      asdfaqwer		axxxo",
387	      \ "\t\t\t\t	      a		axxxoi",
388	      \ "\t\t\t\t	     fa		axxxoi",
389	      \ "\t\t\t\t	    dfa		axxxoi",
390	      \ "\t\t\t\t	   sdfa		axxxoi",
391	      \ "\t\t\t\t	  asdfa		axxxoi",
392	      \ "\t\t\t\t	 xasdfa		axxxoi",
393	      \ "\t\t\t\t	asxxdfa		axxxoi",
394	      \ "\t\t\t\t       asxa;ofa		axxxoi",
395	      \ "\t\t\t\t      asdfaqwer		axxxoi",
396	      \ "\t\t\t\t	      a		axxxoik",
397	      \ "\t\t\t\t	     fa		axxxoik",
398	      \ "\t\t\t\t	    dfa		axxxoik",
399	      \ "\t\t\t\t	   sdfa		axxxoik",
400	      \ "\t\t\t\t	  asdfa		axxxoik",
401	      \ "\t\t\t\t	 xasdfa		axxxoik",
402	      \ "\t\t\t\t	asxxdfa		axxxoik",
403	      \ "\t\t\t\t       asxa;ofa		axxxoik",
404	      \ "\t\t\t\t      asdfaqwer		axxxoik",
405	      \ "\t\t\t\t	      a		axxxoike",
406	      \ "\t\t\t\t	     fa		axxxoike",
407	      \ "\t\t\t\t	    dfa		axxxoike",
408	      \ "\t\t\t\t	   sdfa		axxxoike",
409	      \ "\t\t\t\t	  asdfa		axxxoike",
410	      \ "\t\t\t\t	 xasdfa		axxxoike",
411	      \ "\t\t\t\t	asxxdfa		axxxoike",
412	      \ "\t\t\t\t       asxa;ofa		axxxoike",
413	      \ "\t\t\t\t      asdfaqwer		axxxoike",
414	      \ "\t\t\t\t	      a		axxxoikey",
415	      \ "\t\t\t\t	     fa		axxxoikey",
416	      \ "\t\t\t\t	    dfa		axxxoikey",
417	      \ "\t\t\t\t	   sdfa		axxxoikey",
418	      \ "\t\t\t\t	  asdfa		axxxoikey",
419	      \ "\t\t\t\t	 xasdfa		axxxoikey",
420	      \ "\t\t\t\t	asxxdfa		axxxoikey",
421	      \ "\t\t\t\t       asxa;ofa		axxxoikey",
422	      \ "\t\t\t\t      asdfaqwer		axxxoikey",
423	      \ ""
424	      \ ], getline(1, '$'))
425  enew!
426
427  " align text with 'wrapmargin'
428  50vnew
429  call setline(1, ['Vim'])
430  setl textwidth=0
431  setl wrapmargin=30
432  right
433  call assert_equal("\t\t Vim", getline(1))
434  q!
435
436  set tw&
437endfunc
438
439" Test formatting a paragraph.
440func Test_format_para()
441  enew!
442  set fo+=tcroql tw=72
443
444  call append(0, [
445	\ "xxxxx xx xxxxxx ",
446	\ "xxxxxxx xxxxxxxxx xxx xxxx xxxxx xxxxx xxx xx",
447	\ "xxxxxxxxxxxxxxxxxx xxxxx xxxx, xxxx xxxx xxxx xxxx xxx xx xx",
448	\ "xx xxxxxxx. xxxx xxxx.",
449	\ "",
450	\ "> xx xx, xxxx xxxx xxx xxxx xxx xxxxx xxx xxx xxxxxxx xxx xxxxx",
451	\ "> xxxxxx xxxxxxx: xxxx xxxxxxx, xx xxxxxx xxxx xxxxxxxxxx"
452	\ ])
453  exe "normal /xxxxxxxx$\<CR>"
454  normal 0gq6kk
455  call assert_equal([
456	\ "xxxxx xx xxxxxx xxxxxxx xxxxxxxxx xxx xxxx xxxxx xxxxx xxx xx",
457	\ "xxxxxxxxxxxxxxxxxx xxxxx xxxx, xxxx xxxx xxxx xxxx xxx xx xx xx xxxxxxx.",
458	\ "xxxx xxxx.",
459	\ "",
460	\ "> xx xx, xxxx xxxx xxx xxxx xxx xxxxx xxx xxx xxxxxxx xxx xxxxx xxxxxx",
461	\ "> xxxxxxx: xxxx xxxxxxx, xx xxxxxx xxxx xxxxxxxxxx",
462	\ ""
463	\ ], getline(1, '$'))
464
465  set fo& tw&
466  enew!
467endfunc
468
469" Test undo after ":%s" and formatting.
470func Test_format_undo()
471  enew!
472  map gg :.,.+2s/^/x/<CR>kk:set tw=3<CR>gqq
473
474  call append(0, [
475	      \ "aa aa aa aa",
476	      \ "bb bb bb bb",
477	      \ "cc cc cc cc"
478	      \ ])
479  " undo/redo here to make the next undo only work on the following changes
480  exe "normal i\<C-G>u"
481  call cursor(1,1)
482  normal ggu
483  call assert_equal([
484	      \ "aa aa aa aa",
485	      \ "bb bb bb bb",
486	      \ "cc cc cc cc",
487	      \ ""
488	      \ ], getline(1, '$'))
489
490  unmap gg
491  set tw&
492  enew!
493endfunc
494
495func Test_format_list_auto()
496  new
497  call setline(1, ['1. abc', '2. def', '3.  ghi'])
498  set fo=tan ai bs=2
499  call feedkeys("3G0lli\<BS>\<BS>x\<Esc>", 'tx')
500  call assert_equal('2. defx ghi', getline(2))
501  bwipe!
502  set fo& ai& bs&
503endfunc
504
505func Test_crash_github_issue_5095()
506  CheckFeature autocmd
507
508  " This used to segfault, see https://github.com/vim/vim/issues/5095
509  augroup testing
510    au BufNew x center
511  augroup END
512
513  next! x
514
515  bw
516  augroup testing
517    au!
518  augroup END
519  augroup! testing
520endfunc
521
522" Test for formatting multi-byte text with 'fo=t'
523func Test_tw_2_fo_t()
524  new
525  let t =<< trim END
526    {
527    ＸＹＺ
528    abc ＸＹＺ
529    }
530  END
531  call setline(1, t)
532  call cursor(2, 1)
533
534  set tw=2 fo=t
535  let t =<< trim END
536    ＸＹＺ
537    abc ＸＹＺ
538  END
539  exe "normal gqgqjgqgq"
540  exe "normal o\n" . join(t, "\n")
541
542  let expected =<< trim END
543    {
544    ＸＹＺ
545    abc
546    ＸＹＺ
547
548    ＸＹＺ
549    abc
550    ＸＹＺ
551    }
552  END
553  call assert_equal(expected, getline(1, '$'))
554
555  set tw& fo&
556  bwipe!
557endfunc
558
559" Test for formatting multi-byte text with 'fo=tm' and 'tw=1'
560func Test_tw_1_fo_tm()
561  new
562  let t =<< trim END
563    {
564    Ｘ
565    Ｘa
566    Ｘ a
567    ＸＹ
568    Ｘ Ｙ
569    }
570  END
571  call setline(1, t)
572  call cursor(2, 1)
573
574  set tw=1 fo=tm
575  let t =<< trim END
576    Ｘ
577    Ｘa
578    Ｘ a
579    ＸＹ
580    Ｘ Ｙ
581  END
582  exe "normal gqgqjgqgqjgqgqjgqgqjgqgq"
583  exe "normal o\n" . join(t, "\n")
584
585  let expected =<< trim END
586    {
587    Ｘ
588    Ｘ
589    a
590    Ｘ
591    a
592    Ｘ
593    Ｙ
594    Ｘ
595    Ｙ
596
597    Ｘ
598    Ｘ
599    a
600    Ｘ
601    a
602    Ｘ
603    Ｙ
604    Ｘ
605    Ｙ
606    }
607  END
608  call assert_equal(expected, getline(1, '$'))
609
610  set tw& fo&
611  bwipe!
612endfunc
613
614" Test for formatting multi-byte text with 'fo=tm' and 'tw=2'
615func Test_tw_2_fo_tm()
616  new
617  let t =<< trim END
618    {
619    Ｘ
620    Ｘa
621    Ｘ a
622    ＸＹ
623    Ｘ Ｙ
624    aＸ
625    abＸ
626    abcＸ
627    abＸ c
628    abＸＹ
629    }
630  END
631  call setline(1, t)
632  call cursor(2, 1)
633
634  set tw=2 fo=tm
635  let t =<< trim END
636    Ｘ
637    Ｘa
638    Ｘ a
639    ＸＹ
640    Ｘ Ｙ
641    aＸ
642    abＸ
643    abcＸ
644    abＸ c
645    abＸＹ
646  END
647  exe "normal gqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgq"
648  exe "normal o\n" . join(t, "\n")
649
650  let expected =<< trim END
651    {
652    Ｘ
653    Ｘ
654    a
655    Ｘ
656    a
657    Ｘ
658    Ｙ
659    Ｘ
660    Ｙ
661    a
662    Ｘ
663    ab
664    Ｘ
665    abc
666    Ｘ
667    ab
668    Ｘ
669    c
670    ab
671    Ｘ
672    Ｙ
673
674    Ｘ
675    Ｘ
676    a
677    Ｘ
678    a
679    Ｘ
680    Ｙ
681    Ｘ
682    Ｙ
683    a
684    Ｘ
685    ab
686    Ｘ
687    abc
688    Ｘ
689    ab
690    Ｘ
691    c
692    ab
693    Ｘ
694    Ｙ
695    }
696  END
697  call assert_equal(expected, getline(1, '$'))
698
699  set tw& fo&
700  bwipe!
701endfunc
702
703" Test for formatting multi-byte text with 'fo=tm', 'tw=2' and 'autoindent'.
704func Test_tw_2_fo_tm_ai()
705  new
706  let t =<< trim END
707    {
708      Ｘ
709      Ｘa
710    }
711  END
712  call setline(1, t)
713  call cursor(2, 1)
714
715  set ai tw=2 fo=tm
716  let t =<< trim END
717    Ｘ
718    Ｘa
719  END
720  exe "normal gqgqjgqgq"
721  exe "normal o\n" . join(t, "\n")
722
723  let expected =<< trim END
724    {
725      Ｘ
726      Ｘ
727      a
728
729      Ｘ
730      Ｘ
731      a
732    }
733  END
734  call assert_equal(expected, getline(1, '$'))
735
736  set tw& fo& ai&
737  bwipe!
738endfunc
739
740" Test for formatting multi-byte text with 'fo=tm', 'tw=2' and 'noai'.
741func Test_tw_2_fo_tm_noai()
742  new
743  let t =<< trim END
744    {
745      Ｘ
746      Ｘa
747    }
748  END
749  call setline(1, t)
750  call cursor(2, 1)
751
752  set noai tw=2 fo=tm
753  exe "normal gqgqjgqgqo\n  Ｘ\n  Ｘa"
754
755  let expected =<< trim END
756    {
757      Ｘ
758      Ｘ
759    a
760
761      Ｘ
762      Ｘ
763    a
764    }
765  END
766  call assert_equal(expected, getline(1, '$'))
767
768  set tw& fo& ai&
769  bwipe!
770endfunc
771
772func Test_tw_2_fo_cqm_com()
773  new
774  let t =<< trim END
775    {
776    Ｘ
777    Ｘa
778    ＸaＹ
779    ＸＹ
780    ＸＹＺ
781    Ｘ Ｙ
782    Ｘ ＹＺ
783    ＸＸ
784    ＸＸa
785    ＸＸＹ
786    }
787  END
788  call setline(1, t)
789  call cursor(2, 1)
790
791  set tw=2 fo=cqm comments=n:Ｘ
792  exe "normal gqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgq"
793  let t =<< trim END
794    Ｘ
795    Ｘa
796    ＸaＹ
797    ＸＹ
798    ＸＹＺ
799    Ｘ Ｙ
800    Ｘ ＹＺ
801    ＸＸ
802    ＸＸa
803    ＸＸＹ
804  END
805  exe "normal o\n" . join(t, "\n")
806
807  let expected =<< trim END
808    {
809    Ｘ
810    Ｘa
811    Ｘa
812    ＸＹ
813    ＸＹ
814    ＸＹ
815    ＸＺ
816    Ｘ Ｙ
817    Ｘ Ｙ
818    Ｘ Ｚ
819    ＸＸ
820    ＸＸa
821    ＸＸＹ
822
823    Ｘ
824    Ｘa
825    Ｘa
826    ＸＹ
827    ＸＹ
828    ＸＹ
829    ＸＺ
830    Ｘ Ｙ
831    Ｘ Ｙ
832    Ｘ Ｚ
833    ＸＸ
834    ＸＸa
835    ＸＸＹ
836    }
837  END
838  call assert_equal(expected, getline(1, '$'))
839
840  set tw& fo& comments&
841  bwipe!
842endfunc
843
844func Test_tw_2_fo_tm_replace()
845  new
846  let t =<< trim END
847    {
848
849    }
850  END
851  call setline(1, t)
852  call cursor(2, 1)
853
854  set tw=2 fo=tm
855  exe "normal RＸa"
856
857  let expected =<< trim END
858    {
859    Ｘ
860    a
861    }
862  END
863  call assert_equal(expected, getline(1, '$'))
864
865  set tw& fo&
866  bwipe!
867endfunc
868
869" Test for 'matchpairs' with multibyte chars
870func Test_mps()
871  new
872  let t =<< trim END
873    {
874    ‘ two three ’ four
875    }
876  END
877  call setline(1, t)
878  call cursor(2, 1)
879
880  exe "set mps+=\u2018:\u2019"
881  normal d%
882
883  let expected =<< trim END
884    {
885     four
886    }
887  END
888  call assert_equal(expected, getline(1, '$'))
889
890  set mps&
891  bwipe!
892endfunc
893
894" Test for ra on multi-byte characters
895func Test_ra_multibyte()
896  new
897  let t =<< trim END
898    ra test
899    ａbbａ
900    ａａb
901  END
902  call setline(1, t)
903  call cursor(1, 1)
904
905  normal jVjra
906
907  let expected =<< trim END
908    ra test
909    aaaa
910    aaa
911  END
912  call assert_equal(expected, getline(1, '$'))
913
914  bwipe!
915endfunc
916
917" Test for 'whichwrap' with multi-byte character
918func Test_whichwrap_multi_byte()
919  new
920  let t =<< trim END
921    á
922    x
923  END
924  call setline(1, t)
925  call cursor(2, 1)
926
927  set whichwrap+=h
928  normal dh
929  set whichwrap&
930
931  let expected =<< trim END
932    áx
933  END
934  call assert_equal(expected, getline(1, '$'))
935
936  bwipe!
937endfunc
938
939func Test_substitute()
940  call assert_equal('a１a２a３a', substitute('１２３', '\zs', 'a', 'g'))
941endfunc
942
943" vim: shiftwidth=2 sts=2 expandtab
944