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  " align text with 'rightleft'
437  if has('rightleft')
438    new
439    call setline(1, 'Vim')
440    setlocal rightleft
441    left 20
442    setlocal norightleft
443    call assert_equal("\t\t Vim", getline(1))
444    setlocal rightleft
445    right
446    setlocal norightleft
447    call assert_equal("Vim", getline(1))
448    close!
449  endif
450
451  set tw&
452endfunc
453
454" Test formatting a paragraph.
455func Test_format_para()
456  enew!
457  set fo+=tcroql tw=72
458
459  call append(0, [
460	\ "xxxxx xx xxxxxx ",
461	\ "xxxxxxx xxxxxxxxx xxx xxxx xxxxx xxxxx xxx xx",
462	\ "xxxxxxxxxxxxxxxxxx xxxxx xxxx, xxxx xxxx xxxx xxxx xxx xx xx",
463	\ "xx xxxxxxx. xxxx xxxx.",
464	\ "",
465	\ "> xx xx, xxxx xxxx xxx xxxx xxx xxxxx xxx xxx xxxxxxx xxx xxxxx",
466	\ "> xxxxxx xxxxxxx: xxxx xxxxxxx, xx xxxxxx xxxx xxxxxxxxxx"
467	\ ])
468  exe "normal /xxxxxxxx$\<CR>"
469  normal 0gq6kk
470  call assert_equal([
471	\ "xxxxx xx xxxxxx xxxxxxx xxxxxxxxx xxx xxxx xxxxx xxxxx xxx xx",
472	\ "xxxxxxxxxxxxxxxxxx xxxxx xxxx, xxxx xxxx xxxx xxxx xxx xx xx xx xxxxxxx.",
473	\ "xxxx xxxx.",
474	\ "",
475	\ "> xx xx, xxxx xxxx xxx xxxx xxx xxxxx xxx xxx xxxxxxx xxx xxxxx xxxxxx",
476	\ "> xxxxxxx: xxxx xxxxxxx, xx xxxxxx xxxx xxxxxxxxxx",
477	\ ""
478	\ ], getline(1, '$'))
479
480  set fo& tw&
481  enew!
482endfunc
483
484" Test undo after ":%s" and formatting.
485func Test_format_undo()
486  enew!
487  map gg :.,.+2s/^/x/<CR>kk:set tw=3<CR>gqq
488
489  call append(0, [
490	      \ "aa aa aa aa",
491	      \ "bb bb bb bb",
492	      \ "cc cc cc cc"
493	      \ ])
494  " undo/redo here to make the next undo only work on the following changes
495  exe "normal i\<C-G>u"
496  call cursor(1,1)
497  normal ggu
498  call assert_equal([
499	      \ "aa aa aa aa",
500	      \ "bb bb bb bb",
501	      \ "cc cc cc cc",
502	      \ ""
503	      \ ], getline(1, '$'))
504
505  unmap gg
506  set tw&
507  enew!
508endfunc
509
510func Test_format_list_auto()
511  new
512  call setline(1, ['1. abc', '2. def', '3.  ghi'])
513  set fo=tan ai bs=2
514  call feedkeys("3G0lli\<BS>\<BS>x\<Esc>", 'tx')
515  call assert_equal('2. defx ghi', getline(2))
516  bwipe!
517  set fo& ai& bs&
518endfunc
519
520func Test_crash_github_issue_5095()
521  CheckFeature autocmd
522
523  " This used to segfault, see https://github.com/vim/vim/issues/5095
524  augroup testing
525    au BufNew x center
526  augroup END
527
528  next! x
529
530  bw
531  augroup testing
532    au!
533  augroup END
534  augroup! testing
535endfunc
536
537" Test for formatting multi-byte text with 'fo=t'
538func Test_tw_2_fo_t()
539  new
540  let t =<< trim END
541    {
542    ＸＹＺ
543    abc ＸＹＺ
544    }
545  END
546  call setline(1, t)
547  call cursor(2, 1)
548
549  set tw=2 fo=t
550  let t =<< trim END
551    ＸＹＺ
552    abc ＸＹＺ
553  END
554  exe "normal gqgqjgqgq"
555  exe "normal o\n" . join(t, "\n")
556
557  let expected =<< trim END
558    {
559    ＸＹＺ
560    abc
561    ＸＹＺ
562
563    ＸＹＺ
564    abc
565    ＸＹＺ
566    }
567  END
568  call assert_equal(expected, getline(1, '$'))
569
570  set tw& fo&
571  bwipe!
572endfunc
573
574" Test for formatting multi-byte text with 'fo=tm' and 'tw=1'
575func Test_tw_1_fo_tm()
576  new
577  let t =<< trim END
578    {
579    Ｘ
580    Ｘa
581    Ｘ a
582    ＸＹ
583    Ｘ Ｙ
584    }
585  END
586  call setline(1, t)
587  call cursor(2, 1)
588
589  set tw=1 fo=tm
590  let t =<< trim END
591    Ｘ
592    Ｘa
593    Ｘ a
594    ＸＹ
595    Ｘ Ｙ
596  END
597  exe "normal gqgqjgqgqjgqgqjgqgqjgqgq"
598  exe "normal o\n" . join(t, "\n")
599
600  let expected =<< trim END
601    {
602    Ｘ
603    Ｘ
604    a
605    Ｘ
606    a
607    Ｘ
608    Ｙ
609    Ｘ
610    Ｙ
611
612    Ｘ
613    Ｘ
614    a
615    Ｘ
616    a
617    Ｘ
618    Ｙ
619    Ｘ
620    Ｙ
621    }
622  END
623  call assert_equal(expected, getline(1, '$'))
624
625  set tw& fo&
626  bwipe!
627endfunc
628
629" Test for formatting multi-byte text with 'fo=tm' and 'tw=2'
630func Test_tw_2_fo_tm()
631  new
632  let t =<< trim END
633    {
634    Ｘ
635    Ｘa
636    Ｘ a
637    ＸＹ
638    Ｘ Ｙ
639    aＸ
640    abＸ
641    abcＸ
642    abＸ c
643    abＸＹ
644    }
645  END
646  call setline(1, t)
647  call cursor(2, 1)
648
649  set tw=2 fo=tm
650  let t =<< trim END
651    Ｘ
652    Ｘa
653    Ｘ a
654    ＸＹ
655    Ｘ Ｙ
656    aＸ
657    abＸ
658    abcＸ
659    abＸ c
660    abＸＹ
661  END
662  exe "normal gqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgq"
663  exe "normal o\n" . join(t, "\n")
664
665  let expected =<< trim END
666    {
667    Ｘ
668    Ｘ
669    a
670    Ｘ
671    a
672    Ｘ
673    Ｙ
674    Ｘ
675    Ｙ
676    a
677    Ｘ
678    ab
679    Ｘ
680    abc
681    Ｘ
682    ab
683    Ｘ
684    c
685    ab
686    Ｘ
687    Ｙ
688
689    Ｘ
690    Ｘ
691    a
692    Ｘ
693    a
694    Ｘ
695    Ｙ
696    Ｘ
697    Ｙ
698    a
699    Ｘ
700    ab
701    Ｘ
702    abc
703    Ｘ
704    ab
705    Ｘ
706    c
707    ab
708    Ｘ
709    Ｙ
710    }
711  END
712  call assert_equal(expected, getline(1, '$'))
713
714  set tw& fo&
715  bwipe!
716endfunc
717
718" Test for formatting multi-byte text with 'fo=tm', 'tw=2' and 'autoindent'.
719func Test_tw_2_fo_tm_ai()
720  new
721  let t =<< trim END
722    {
723      Ｘ
724      Ｘa
725    }
726  END
727  call setline(1, t)
728  call cursor(2, 1)
729
730  set ai tw=2 fo=tm
731  let t =<< trim END
732    Ｘ
733    Ｘa
734  END
735  exe "normal gqgqjgqgq"
736  exe "normal o\n" . join(t, "\n")
737
738  let expected =<< trim END
739    {
740      Ｘ
741      Ｘ
742      a
743
744      Ｘ
745      Ｘ
746      a
747    }
748  END
749  call assert_equal(expected, getline(1, '$'))
750
751  set tw& fo& ai&
752  bwipe!
753endfunc
754
755" Test for formatting multi-byte text with 'fo=tm', 'tw=2' and 'noai'.
756func Test_tw_2_fo_tm_noai()
757  new
758  let t =<< trim END
759    {
760      Ｘ
761      Ｘa
762    }
763  END
764  call setline(1, t)
765  call cursor(2, 1)
766
767  set noai tw=2 fo=tm
768  exe "normal gqgqjgqgqo\n  Ｘ\n  Ｘa"
769
770  let expected =<< trim END
771    {
772      Ｘ
773      Ｘ
774    a
775
776      Ｘ
777      Ｘ
778    a
779    }
780  END
781  call assert_equal(expected, getline(1, '$'))
782
783  set tw& fo& ai&
784  bwipe!
785endfunc
786
787func Test_tw_2_fo_cqm_com()
788  new
789  let t =<< trim END
790    {
791    Ｘ
792    Ｘa
793    ＸaＹ
794    ＸＹ
795    ＸＹＺ
796    Ｘ Ｙ
797    Ｘ ＹＺ
798    ＸＸ
799    ＸＸa
800    ＸＸＹ
801    }
802  END
803  call setline(1, t)
804  call cursor(2, 1)
805
806  set tw=2 fo=cqm comments=n:Ｘ
807  exe "normal gqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgq"
808  let t =<< trim END
809    Ｘ
810    Ｘa
811    ＸaＹ
812    ＸＹ
813    ＸＹＺ
814    Ｘ Ｙ
815    Ｘ ＹＺ
816    ＸＸ
817    ＸＸa
818    ＸＸＹ
819  END
820  exe "normal o\n" . join(t, "\n")
821
822  let expected =<< trim END
823    {
824    Ｘ
825    Ｘa
826    Ｘa
827    ＸＹ
828    ＸＹ
829    ＸＹ
830    ＸＺ
831    Ｘ Ｙ
832    Ｘ Ｙ
833    Ｘ Ｚ
834    ＸＸ
835    ＸＸa
836    ＸＸＹ
837
838    Ｘ
839    Ｘa
840    Ｘa
841    ＸＹ
842    ＸＹ
843    ＸＹ
844    ＸＺ
845    Ｘ Ｙ
846    Ｘ Ｙ
847    Ｘ Ｚ
848    ＸＸ
849    ＸＸa
850    ＸＸＹ
851    }
852  END
853  call assert_equal(expected, getline(1, '$'))
854
855  set tw& fo& comments&
856  bwipe!
857endfunc
858
859func Test_tw_2_fo_tm_replace()
860  new
861  let t =<< trim END
862    {
863
864    }
865  END
866  call setline(1, t)
867  call cursor(2, 1)
868
869  set tw=2 fo=tm
870  exe "normal RＸa"
871
872  let expected =<< trim END
873    {
874    Ｘ
875    a
876    }
877  END
878  call assert_equal(expected, getline(1, '$'))
879
880  set tw& fo&
881  bwipe!
882endfunc
883
884" Test for 'matchpairs' with multibyte chars
885func Test_mps()
886  new
887  let t =<< trim END
888    {
889    ‘ two three ’ four
890    }
891  END
892  call setline(1, t)
893  call cursor(2, 1)
894
895  exe "set mps+=\u2018:\u2019"
896  normal d%
897
898  let expected =<< trim END
899    {
900     four
901    }
902  END
903  call assert_equal(expected, getline(1, '$'))
904
905  set mps&
906  bwipe!
907endfunc
908
909" Test for ra on multi-byte characters
910func Test_ra_multibyte()
911  new
912  let t =<< trim END
913    ra test
914    ａbbａ
915    ａａb
916  END
917  call setline(1, t)
918  call cursor(1, 1)
919
920  normal jVjra
921
922  let expected =<< trim END
923    ra test
924    aaaa
925    aaa
926  END
927  call assert_equal(expected, getline(1, '$'))
928
929  bwipe!
930endfunc
931
932" Test for 'whichwrap' with multi-byte character
933func Test_whichwrap_multi_byte()
934  new
935  let t =<< trim END
936    á
937    x
938  END
939  call setline(1, t)
940  call cursor(2, 1)
941
942  set whichwrap+=h
943  normal dh
944  set whichwrap&
945
946  let expected =<< trim END
947    áx
948  END
949  call assert_equal(expected, getline(1, '$'))
950
951  bwipe!
952endfunc
953
954" Test for the 'f' flag in 'comments' (only the first line has the comment
955" string)
956func Test_firstline_comment()
957  new
958  setlocal comments=f:- fo+=ro
959  exe "normal i- B\nD\<C-C>ggoC\<C-C>ggOA\<C-C>"
960  call assert_equal(['A', '- B', '  C', '  D'], getline(1, '$'))
961  %d
962  setlocal comments=:-
963  exe "normal i- B\nD\<C-C>ggoC\<C-C>ggOA\<C-C>"
964  call assert_equal(['- A', '- B', '- C', '- D'], getline(1, '$'))
965  %bw!
966endfunc
967
968" Test for the 'r' flag in 'comments' (right align comment)
969func Test_comment_rightalign()
970  new
971  setlocal comments=sr:/***,m:**,ex-2:******/ fo+=ro
972  exe "normal i=\<C-C>o\t  /***\nD\n/"
973  exe "normal 2GOA\<C-C>joB\<C-C>jOC\<C-C>joE\<C-C>GOF\<C-C>joG"
974  let expected =<< trim END
975    =
976    A
977    	  /***
978    	    ** B
979    	    ** C
980    	    ** D
981    	    ** E
982    	    **     F
983    	    ******/
984    G
985  END
986  call assert_equal(expected, getline(1, '$'))
987  %bw!
988endfunc
989
990" Test for the 'b' flag in 'comments'
991func Test_comment_blank()
992  new
993  setlocal comments=b:* fo+=ro
994  exe "normal i* E\nF\n\<BS>G\nH\<C-C>ggOC\<C-C>O\<BS>B\<C-C>OA\<C-C>2joD"
995  let expected =<< trim END
996    A
997    *B
998    * C
999    * D
1000    * E
1001    * F
1002    *G
1003    H
1004  END
1005  call assert_equal(expected, getline(1, '$'))
1006  %bw!
1007endfunc
1008
1009" Test for the 'n' flag in comments
1010func Test_comment_nested()
1011  new
1012  setlocal comments=n:> fo+=ro
1013  exe "normal i> B\nD\<C-C>ggOA\<C-C>joC\<C-C>Go\<BS>>>> F\nH"
1014  exe "normal 5GOE\<C-C>6GoG"
1015  let expected =<< trim END
1016    > A
1017    > B
1018    > C
1019    > D
1020    >>>> E
1021    >>>> F
1022    >>>> G
1023    >>>> H
1024  END
1025  call assert_equal(expected, getline(1, '$'))
1026  %bw!
1027endfunc
1028
1029" Test for a space character in 'comments' setting
1030func Test_comment_space()
1031  new
1032  setlocal comments=b:\ > fo+=ro
1033  exe "normal i> B\nD\<C-C>ggOA\<C-C>joC"
1034  exe "normal Go > F\nH\<C-C>kOE\<C-C>joG"
1035  let expected =<< trim END
1036    A
1037    > B
1038    C
1039    D
1040     > E
1041     > F
1042     > G
1043     > H
1044  END
1045  call assert_equal(expected, getline(1, '$'))
1046  %bw!
1047endfunc
1048
1049" Test for the 'O' flag in 'comments'
1050func Test_comment_O()
1051  new
1052  setlocal comments=Ob:* fo+=ro
1053  exe "normal i* B\nD\<C-C>kOA\<C-C>joC"
1054  let expected =<< trim END
1055    A
1056    * B
1057    * C
1058    * D
1059  END
1060  call assert_equal(expected, getline(1, '$'))
1061  %bw!
1062endfunc
1063
1064" Test for 'a' and 'w' flags in 'formatoptions'
1065func Test_fo_a_w()
1066  new
1067  setlocal fo+=aw tw=10
1068  call feedkeys("iabc abc a abc\<Esc>k0weade", 'xt')
1069  call assert_equal(['abc abcde ', 'a abc'], getline(1, '$'))
1070  %bw!
1071endfunc
1072
1073" Test for 'j' flag in 'formatoptions'
1074func Test_fo_j()
1075  new
1076  setlocal fo+=j comments=://
1077  call setline(1, ['i++; // comment1', '           // comment2'])
1078  normal J
1079  call assert_equal('i++; // comment1 comment2', getline(1))
1080  setlocal fo-=j
1081  call setline(1, ['i++; // comment1', '           // comment2'])
1082  normal J
1083  call assert_equal('i++; // comment1 // comment2', getline(1))
1084  " Test with nested comments
1085  setlocal fo+=j comments=n:>,n:)
1086  call setline(1, ['i++; > ) > ) comment1', '           > ) comment2'])
1087  normal J
1088  call assert_equal('i++; > ) > ) comment1 comment2', getline(1))
1089  %bw!
1090endfunc
1091
1092" vim: shiftwidth=2 sts=2 expandtab
1093