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