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  call setline(1, ['Vim'])
429  set textwidth=0
430  set wrapmargin=60
431  right
432  call assert_equal("\t\t Vim", getline(1))
433  set wrapmargin&
434
435  set tw&
436endfunc
437
438" Test formatting a paragraph.
439func Test_format_para()
440  enew!
441  set fo+=tcroql tw=72
442
443  call append(0, [
444	\ "xxxxx xx xxxxxx ",
445	\ "xxxxxxx xxxxxxxxx xxx xxxx xxxxx xxxxx xxx xx",
446	\ "xxxxxxxxxxxxxxxxxx xxxxx xxxx, xxxx xxxx xxxx xxxx xxx xx xx",
447	\ "xx xxxxxxx. xxxx xxxx.",
448	\ "",
449	\ "> xx xx, xxxx xxxx xxx xxxx xxx xxxxx xxx xxx xxxxxxx xxx xxxxx",
450	\ "> xxxxxx xxxxxxx: xxxx xxxxxxx, xx xxxxxx xxxx xxxxxxxxxx"
451	\ ])
452  exe "normal /xxxxxxxx$\<CR>"
453  normal 0gq6kk
454  call assert_equal([
455	\ "xxxxx xx xxxxxx xxxxxxx xxxxxxxxx xxx xxxx xxxxx xxxxx xxx xx",
456	\ "xxxxxxxxxxxxxxxxxx xxxxx xxxx, xxxx xxxx xxxx xxxx xxx xx xx xx xxxxxxx.",
457	\ "xxxx xxxx.",
458	\ "",
459	\ "> xx xx, xxxx xxxx xxx xxxx xxx xxxxx xxx xxx xxxxxxx xxx xxxxx xxxxxx",
460	\ "> xxxxxxx: xxxx xxxxxxx, xx xxxxxx xxxx xxxxxxxxxx",
461	\ ""
462	\ ], getline(1, '$'))
463
464  set fo& tw&
465  enew!
466endfunc
467
468" Test undo after ":%s" and formatting.
469func Test_format_undo()
470  enew!
471  map gg :.,.+2s/^/x/<CR>kk:set tw=3<CR>gqq
472
473  call append(0, [
474	      \ "aa aa aa aa",
475	      \ "bb bb bb bb",
476	      \ "cc cc cc cc"
477	      \ ])
478  " undo/redo here to make the next undo only work on the following changes
479  exe "normal i\<C-G>u"
480  call cursor(1,1)
481  normal ggu
482  call assert_equal([
483	      \ "aa aa aa aa",
484	      \ "bb bb bb bb",
485	      \ "cc cc cc cc",
486	      \ ""
487	      \ ], getline(1, '$'))
488
489  unmap gg
490  set tw&
491  enew!
492endfunc
493
494func Test_format_list_auto()
495  new
496  call setline(1, ['1. abc', '2. def', '3.  ghi'])
497  set fo=tan ai bs=2
498  call feedkeys("3G0lli\<BS>\<BS>x\<Esc>", 'tx')
499  call assert_equal('2. defx ghi', getline(2))
500  bwipe!
501  set fo& ai& bs&
502endfunc
503
504func Test_crash_github_issue_5095()
505  CheckFeature autocmd
506
507  " This used to segfault, see https://github.com/vim/vim/issues/5095
508  augroup testing
509    au BufNew x center
510  augroup END
511
512  next! x
513
514  bw
515  augroup testing
516    au!
517  augroup END
518  augroup! testing
519endfunc
520
521" Test for formatting multi-byte text with 'fo=t'
522func Test_tw_2_fo_t()
523  new
524  let t =<< trim END
525    {
526    ＸＹＺ
527    abc ＸＹＺ
528    }
529  END
530  call setline(1, t)
531  call cursor(2, 1)
532
533  set tw=2 fo=t
534  let t =<< trim END
535    ＸＹＺ
536    abc ＸＹＺ
537  END
538  exe "normal gqgqjgqgq"
539  exe "normal o\n" . join(t, "\n")
540
541  let expected =<< trim END
542    {
543    ＸＹＺ
544    abc
545    ＸＹＺ
546
547    ＸＹＺ
548    abc
549    ＸＹＺ
550    }
551  END
552  call assert_equal(expected, getline(1, '$'))
553
554  set tw& fo&
555  bwipe!
556endfunc
557
558" Test for formatting multi-byte text with 'fo=tm' and 'tw=1'
559func Test_tw_1_fo_tm()
560  new
561  let t =<< trim END
562    {
563    Ｘ
564    Ｘa
565    Ｘ a
566    ＸＹ
567    Ｘ Ｙ
568    }
569  END
570  call setline(1, t)
571  call cursor(2, 1)
572
573  set tw=1 fo=tm
574  let t =<< trim END
575    Ｘ
576    Ｘa
577    Ｘ a
578    ＸＹ
579    Ｘ Ｙ
580  END
581  exe "normal gqgqjgqgqjgqgqjgqgqjgqgq"
582  exe "normal o\n" . join(t, "\n")
583
584  let expected =<< trim END
585    {
586    Ｘ
587    Ｘ
588    a
589    Ｘ
590    a
591    Ｘ
592    Ｙ
593    Ｘ
594    Ｙ
595
596    Ｘ
597    Ｘ
598    a
599    Ｘ
600    a
601    Ｘ
602    Ｙ
603    Ｘ
604    Ｙ
605    }
606  END
607  call assert_equal(expected, getline(1, '$'))
608
609  set tw& fo&
610  bwipe!
611endfunc
612
613" Test for formatting multi-byte text with 'fo=tm' and 'tw=2'
614func Test_tw_2_fo_tm()
615  new
616  let t =<< trim END
617    {
618    Ｘ
619    Ｘa
620    Ｘ a
621    ＸＹ
622    Ｘ Ｙ
623    aＸ
624    abＸ
625    abcＸ
626    abＸ c
627    abＸＹ
628    }
629  END
630  call setline(1, t)
631  call cursor(2, 1)
632
633  set tw=2 fo=tm
634  let t =<< trim END
635    Ｘ
636    Ｘa
637    Ｘ a
638    ＸＹ
639    Ｘ Ｙ
640    aＸ
641    abＸ
642    abcＸ
643    abＸ c
644    abＸＹ
645  END
646  exe "normal gqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgq"
647  exe "normal o\n" . join(t, "\n")
648
649  let expected =<< trim END
650    {
651    Ｘ
652    Ｘ
653    a
654    Ｘ
655    a
656    Ｘ
657    Ｙ
658    Ｘ
659    Ｙ
660    a
661    Ｘ
662    ab
663    Ｘ
664    abc
665    Ｘ
666    ab
667    Ｘ
668    c
669    ab
670    Ｘ
671    Ｙ
672
673    Ｘ
674    Ｘ
675    a
676    Ｘ
677    a
678    Ｘ
679    Ｙ
680    Ｘ
681    Ｙ
682    a
683    Ｘ
684    ab
685    Ｘ
686    abc
687    Ｘ
688    ab
689    Ｘ
690    c
691    ab
692    Ｘ
693    Ｙ
694    }
695  END
696  call assert_equal(expected, getline(1, '$'))
697
698  set tw& fo&
699  bwipe!
700endfunc
701
702" Test for formatting multi-byte text with 'fo=tm', 'tw=2' and 'autoindent'.
703func Test_tw_2_fo_tm_ai()
704  new
705  let t =<< trim END
706    {
707      Ｘ
708      Ｘa
709    }
710  END
711  call setline(1, t)
712  call cursor(2, 1)
713
714  set ai tw=2 fo=tm
715  let t =<< trim END
716    Ｘ
717    Ｘa
718  END
719  exe "normal gqgqjgqgq"
720  exe "normal o\n" . join(t, "\n")
721
722  let expected =<< trim END
723    {
724      Ｘ
725      Ｘ
726      a
727
728      Ｘ
729      Ｘ
730      a
731    }
732  END
733  call assert_equal(expected, getline(1, '$'))
734
735  set tw& fo& ai&
736  bwipe!
737endfunc
738
739" Test for formatting multi-byte text with 'fo=tm', 'tw=2' and 'noai'.
740func Test_tw_2_fo_tm_noai()
741  new
742  let t =<< trim END
743    {
744      Ｘ
745      Ｘa
746    }
747  END
748  call setline(1, t)
749  call cursor(2, 1)
750
751  set noai tw=2 fo=tm
752  exe "normal gqgqjgqgqo\n  Ｘ\n  Ｘa"
753
754  let expected =<< trim END
755    {
756      Ｘ
757      Ｘ
758    a
759
760      Ｘ
761      Ｘ
762    a
763    }
764  END
765  call assert_equal(expected, getline(1, '$'))
766
767  set tw& fo& ai&
768  bwipe!
769endfunc
770
771func Test_tw_2_fo_cqm_com()
772  new
773  let t =<< trim END
774    {
775    Ｘ
776    Ｘa
777    ＸaＹ
778    ＸＹ
779    ＸＹＺ
780    Ｘ Ｙ
781    Ｘ ＹＺ
782    ＸＸ
783    ＸＸa
784    ＸＸＹ
785    }
786  END
787  call setline(1, t)
788  call cursor(2, 1)
789
790  set tw=2 fo=cqm comments=n:Ｘ
791  exe "normal gqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgq"
792  let t =<< trim END
793    Ｘ
794    Ｘa
795    ＸaＹ
796    ＸＹ
797    ＸＹＺ
798    Ｘ Ｙ
799    Ｘ ＹＺ
800    ＸＸ
801    ＸＸa
802    ＸＸＹ
803  END
804  exe "normal o\n" . join(t, "\n")
805
806  let expected =<< trim END
807    {
808    Ｘ
809    Ｘa
810    Ｘa
811    ＸＹ
812    ＸＹ
813    ＸＹ
814    ＸＺ
815    Ｘ Ｙ
816    Ｘ Ｙ
817    Ｘ Ｚ
818    ＸＸ
819    ＸＸa
820    ＸＸＹ
821
822    Ｘ
823    Ｘa
824    Ｘa
825    ＸＹ
826    ＸＹ
827    ＸＹ
828    ＸＺ
829    Ｘ Ｙ
830    Ｘ Ｙ
831    Ｘ Ｚ
832    ＸＸ
833    ＸＸa
834    ＸＸＹ
835    }
836  END
837  call assert_equal(expected, getline(1, '$'))
838
839  set tw& fo& comments&
840  bwipe!
841endfunc
842
843func Test_tw_2_fo_tm_replace()
844  new
845  let t =<< trim END
846    {
847
848    }
849  END
850  call setline(1, t)
851  call cursor(2, 1)
852
853  set tw=2 fo=tm
854  exe "normal RＸa"
855
856  let expected =<< trim END
857    {
858    Ｘ
859    a
860    }
861  END
862  call assert_equal(expected, getline(1, '$'))
863
864  set tw& fo&
865  bwipe!
866endfunc
867
868" Test for 'matchpairs' with multibyte chars
869func Test_mps()
870  new
871  let t =<< trim END
872    {
873    ‘ two three ’ four
874    }
875  END
876  call setline(1, t)
877  call cursor(2, 1)
878
879  exe "set mps+=\u2018:\u2019"
880  normal d%
881
882  let expected =<< trim END
883    {
884     four
885    }
886  END
887  call assert_equal(expected, getline(1, '$'))
888
889  set mps&
890  bwipe!
891endfunc
892
893" Test for ra on multi-byte characters
894func Test_ra_multibyte()
895  new
896  let t =<< trim END
897    ra test
898    ａbbａ
899    ａａb
900  END
901  call setline(1, t)
902  call cursor(1, 1)
903
904  normal jVjra
905
906  let expected =<< trim END
907    ra test
908    aaaa
909    aaa
910  END
911  call assert_equal(expected, getline(1, '$'))
912
913  bwipe!
914endfunc
915
916" Test for 'whichwrap' with multi-byte character
917func Test_whichwrap_multi_byte()
918  new
919  let t =<< trim END
920    á
921    x
922  END
923  call setline(1, t)
924  call cursor(2, 1)
925
926  set whichwrap+=h
927  normal dh
928  set whichwrap&
929
930  let expected =<< trim END
931    áx
932  END
933  call assert_equal(expected, getline(1, '$'))
934
935  bwipe!
936endfunc
937
938func Test_substitute()
939  call assert_equal('a１a２a３a', substitute('１２３', '\zs', 'a', 'g'))
940endfunc
941
942" vim: shiftwidth=2 sts=2 expandtab
943