]> git.madduck.net Git - etc/vim.git/blob - test/syntax.vader

madduck's git repository

Every one of the projects in this repository is available at the canonical URL git://git.madduck.net/madduck/pub/<projectpath> — see each project's metadata for the exact URL.

All patches and comments are welcome. Please squash your changes to logical commits before using git-format-patch and git-send-email to patches@git.madduck.net. If you'd read over the Git project's submission guidelines and adhered to them, I'd be especially grateful.

SSH access, as well as push access can be individually arranged.

If you use my repositories frequently, consider adding the following snippet to ~/.gitconfig and using the third clone URL listed for each project:

[url "git://git.madduck.net/madduck/"]
  insteadOf = madduck:

Fix last line header folding
[etc/vim.git] / test / syntax.vader
1 Before:
2   unlet! b:mkd_known_filetypes
3   unlet! b:mkd_included_filetypes
4   unlet! g:vim_markdown_math
5
6 Given markdown;
7 a **b** c
8
9 Execute (bold):
10   AssertNotEqual SyntaxOf('a'), 'htmlBold'
11   AssertEqual SyntaxOf('b'), 'htmlBold'
12   AssertNotEqual SyntaxOf('c'), 'htmlBold'
13
14 Given markdown;
15 a __b__ c
16
17 Execute (bold):
18   AssertNotEqual SyntaxOf('a'), 'htmlBold'
19   AssertEqual SyntaxOf('b'), 'htmlBold'
20   AssertNotEqual SyntaxOf('c'), 'htmlBold'
21
22 Given markdown;
23 a *b* c
24
25 Execute (italic):
26   AssertNotEqual SyntaxOf('a'), 'htmlItalic'
27   AssertEqual SyntaxOf('b'), 'htmlItalic'
28   AssertNotEqual SyntaxOf('c'), 'htmlItalic'
29
30 Given markdown;
31 a _b_ c
32
33 Execute (italic):
34   AssertNotEqual SyntaxOf('a'), 'htmlItalic'
35   AssertEqual SyntaxOf('b'), 'htmlItalic'
36   AssertNotEqual SyntaxOf('c'), 'htmlItalic'
37
38 Given markdown;
39 _a_b_
40
41 Execute (italic text has underscores):
42   AssertEqual SyntaxOf('a'), 'htmlItalic'
43   AssertEqual SyntaxOf('b'), 'htmlItalic'
44
45 Given markdown;
46 a \*b\* c
47
48 Execute (not italic with escaped asterisks):
49   AssertNotEqual SyntaxOf('a'), 'htmlItalic'
50   AssertNotEqual SyntaxOf('b'), 'htmlItalic'
51   AssertNotEqual SyntaxOf('c'), 'htmlItalic'
52
53 Given markdown;
54 a \_b\_ c
55
56 Execute (not italic with escaped underscores):
57   AssertNotEqual SyntaxOf('a'), 'htmlItalic'
58   AssertNotEqual SyntaxOf('b'), 'htmlItalic'
59   AssertNotEqual SyntaxOf('c'), 'htmlItalic'
60
61 Given markdown;
62 a _b\_c_ d
63
64 Execute (italic with escaped underscores):
65   AssertNotEqual SyntaxOf('a'), 'htmlItalic'
66   AssertEqual SyntaxOf('b'), 'htmlItalic'
67   AssertEqual SyntaxOf('c'), 'htmlItalic'
68   AssertNotEqual SyntaxOf('d'), 'htmlItalic'
69
70 Given markdown;
71 a_b_c
72
73 Execute (not italic underscores within text):
74   AssertNotEqual SyntaxOf('a'), 'htmlItalic'
75   AssertNotEqual SyntaxOf('b'), 'htmlItalic'
76   AssertNotEqual SyntaxOf('c'), 'htmlItalic'
77
78 Given markdown;
79 a *b\*c* d
80
81 Execute (italic with escaped asterisks):
82   AssertNotEqual SyntaxOf('a'), 'htmlItalic'
83   AssertEqual SyntaxOf('b'), 'htmlItalic'
84   AssertEqual SyntaxOf('c'), 'htmlItalic'
85   AssertNotEqual SyntaxOf('d'), 'htmlItalic'
86
87 Given markdown;
88 a __b\_\_c__ d
89
90 Execute (bold with escaped underscores):
91   AssertNotEqual SyntaxOf('a'), 'htmlBold'
92   AssertEqual SyntaxOf('b'), 'htmlBold'
93   AssertEqual SyntaxOf('c'), 'htmlBold'
94   AssertNotEqual SyntaxOf('d'), 'htmlBold'
95
96 Given markdown;
97 _a b
98 c_ d
99
100 Execute (italic with underscores in multiple lines):
101   AssertEqual SyntaxOf('a'), 'htmlItalic'
102   AssertEqual SyntaxOf('b'), 'htmlItalic'
103   AssertEqual SyntaxOf('c'), 'htmlItalic'
104   AssertNotEqual SyntaxOf('d'), 'htmlItalic'
105
106 Given markdown;
107 __a b
108 c__ d
109
110 Execute (bold with underscores in multiple lines):
111   AssertEqual SyntaxOf('a'), 'htmlBold'
112   AssertEqual SyntaxOf('b'), 'htmlBold'
113   AssertEqual SyntaxOf('c'), 'htmlBold'
114   AssertNotEqual SyntaxOf('d'), 'htmlBold'
115
116 Given markdown;
117 ___a b
118 c___ d
119
120 Execute (bold italic with underscores in multiple lines):
121   AssertEqual SyntaxOf('a'), 'htmlBoldItalic'
122   AssertEqual SyntaxOf('b'), 'htmlBoldItalic'
123   AssertEqual SyntaxOf('c'), 'htmlBoldItalic'
124   AssertNotEqual SyntaxOf('d'), 'htmlBoldItalic'
125
126 Given markdown;
127 *a b
128 c* d
129
130 Execute (italic with asterisks in multiple lines):
131   AssertEqual SyntaxOf('a'), 'htmlItalic'
132   AssertEqual SyntaxOf('b'), 'htmlItalic'
133   AssertEqual SyntaxOf('c'), 'htmlItalic'
134   AssertNotEqual SyntaxOf('d'), 'htmlItalic'
135
136 Given markdown;
137 **a b
138 c** d
139
140 Execute (bold with asterisks in multiple lines):
141   AssertEqual SyntaxOf('a'), 'htmlBold'
142   AssertEqual SyntaxOf('b'), 'htmlBold'
143   AssertEqual SyntaxOf('c'), 'htmlBold'
144   AssertNotEqual SyntaxOf('d'), 'htmlBold'
145
146 Given markdown;
147 ***a b
148 c*** d
149
150 Execute (bold italic with asterisks in multiple lines):
151   AssertEqual SyntaxOf('a'), 'htmlBoldItalic'
152   AssertEqual SyntaxOf('b'), 'htmlBoldItalic'
153   AssertEqual SyntaxOf('c'), 'htmlBoldItalic'
154   AssertNotEqual SyntaxOf('d'), 'htmlBoldItalic'
155
156 Given markdown;
157 *a
158
159 Execute (not italic with an asterisk):
160   AssertNotEqual SyntaxOf('a'), 'htmlItalic'
161
162 Given markdown;
163 [__](a) b
164
165 Execute (not bold with double underscores):
166   AssertNotEqual SyntaxOf('_'), 'htmlBold'
167   AssertNotEqual SyntaxOf('a'), 'htmlBold'
168   AssertNotEqual SyntaxOf('b'), 'htmlBold'
169
170 Given markdown;
171 _a_
172
173 Execute (conceal italic):
174   if has('conceal')
175     setlocal conceallevel=2
176     AssertEqual synconcealed(1, 1)[0], 1
177     AssertEqual synconcealed(1, 2)[0], 0
178     AssertEqual synconcealed(1, 3)[0], 1
179     setlocal conceallevel=0
180   endif
181
182 Execute (disable conceal):
183   if has('conceal')
184     let g:vim_markdown_conceal=0
185     syn off | syn on
186     setlocal conceallevel=2
187     AssertEqual synconcealed(1, 1)[0], 0
188     AssertEqual synconcealed(1, 2)[0], 0
189     AssertEqual synconcealed(1, 3)[0], 0
190
191     let g:vim_markdown_conceal=1
192     syn off | syn on
193     AssertEqual synconcealed(1, 1)[0], 1
194     AssertEqual synconcealed(1, 2)[0], 0
195     AssertEqual synconcealed(1, 3)[0], 1
196
197     setlocal conceallevel=0
198     unlet g:vim_markdown_conceal
199     syn off | syn on
200   endif
201
202 Given markdown;
203 *a*
204
205 Execute (conceal italic):
206   if has('conceal')
207     setlocal conceallevel=2
208     AssertEqual synconcealed(1, 1)[0], 1
209     AssertEqual synconcealed(1, 2)[0], 0
210     AssertEqual synconcealed(1, 3)[0], 1
211     setlocal conceallevel=0
212   endif
213
214 Execute (disable conceal):
215   if has('conceal')
216     let g:vim_markdown_conceal=0
217     syn off | syn on
218     setlocal conceallevel=2
219     AssertEqual synconcealed(1, 1)[0], 0
220     AssertEqual synconcealed(1, 2)[0], 0
221     AssertEqual synconcealed(1, 3)[0], 0
222
223     let g:vim_markdown_conceal=1
224     syn off | syn on
225     AssertEqual synconcealed(1, 1)[0], 1
226     AssertEqual synconcealed(1, 2)[0], 0
227     AssertEqual synconcealed(1, 3)[0], 1
228
229     setlocal conceallevel=0
230     unlet g:vim_markdown_conceal
231     syn off | syn on
232   endif
233
234 Given markdown;
235 __a__
236
237 Execute (conceal bold):
238   if has('conceal')
239     setlocal conceallevel=2
240     AssertEqual synconcealed(1, 1)[0], 1
241     AssertEqual synconcealed(1, 2)[0], 1
242     AssertEqual synconcealed(1, 3)[0], 0
243     AssertEqual synconcealed(1, 4)[0], 1
244     AssertEqual synconcealed(1, 5)[0], 1
245     setlocal conceallevel=0
246   endif
247
248 Execute (disable conceal):
249   if has('conceal')
250     let g:vim_markdown_conceal=0
251     syn off | syn on
252     setlocal conceallevel=2
253     AssertEqual synconcealed(1, 1)[0], 0
254     AssertEqual synconcealed(1, 2)[0], 0
255     AssertEqual synconcealed(1, 3)[0], 0
256     AssertEqual synconcealed(1, 4)[0], 0
257     AssertEqual synconcealed(1, 5)[0], 0
258
259     let g:vim_markdown_conceal=1
260     syn off | syn on
261     AssertEqual synconcealed(1, 1)[0], 1
262     AssertEqual synconcealed(1, 2)[0], 1
263     AssertEqual synconcealed(1, 3)[0], 0
264     AssertEqual synconcealed(1, 4)[0], 1
265     AssertEqual synconcealed(1, 5)[0], 1
266
267     setlocal conceallevel=0
268     unlet g:vim_markdown_conceal
269     syn off | syn on
270   endif
271
272 Given markdown;
273 **a**
274
275 Execute (conceal bold):
276   if has('conceal')
277     setlocal conceallevel=2
278     AssertEqual synconcealed(1, 1)[0], 1
279     AssertEqual synconcealed(1, 2)[0], 1
280     AssertEqual synconcealed(1, 3)[0], 0
281     AssertEqual synconcealed(1, 4)[0], 1
282     AssertEqual synconcealed(1, 5)[0], 1
283     setlocal conceallevel=0
284   endif
285
286 Execute (disable conceal):
287   if has('conceal')
288     let g:vim_markdown_conceal=0
289     syn off | syn on
290     setlocal conceallevel=2
291     AssertEqual synconcealed(1, 1)[0], 0
292     AssertEqual synconcealed(1, 2)[0], 0
293     AssertEqual synconcealed(1, 3)[0], 0
294     AssertEqual synconcealed(1, 4)[0], 0
295     AssertEqual synconcealed(1, 5)[0], 0
296
297     let g:vim_markdown_conceal=1
298     syn off | syn on
299     AssertEqual synconcealed(1, 1)[0], 1
300     AssertEqual synconcealed(1, 2)[0], 1
301     AssertEqual synconcealed(1, 3)[0], 0
302     AssertEqual synconcealed(1, 4)[0], 1
303     AssertEqual synconcealed(1, 5)[0], 1
304
305     setlocal conceallevel=0
306     unlet g:vim_markdown_conceal
307     syn off | syn on
308   endif
309
310 Given markdown;
311 ___a___
312
313 Execute (conceal italic bold):
314   if has('conceal')
315     setlocal conceallevel=2
316     AssertEqual synconcealed(1, 1)[0], 1
317     AssertEqual synconcealed(1, 2)[0], 1
318     AssertEqual synconcealed(1, 3)[0], 1
319     AssertEqual synconcealed(1, 4)[0], 0
320     AssertEqual synconcealed(1, 5)[0], 1
321     AssertEqual synconcealed(1, 6)[0], 1
322     AssertEqual synconcealed(1, 7)[0], 1
323     setlocal conceallevel=0
324   endif
325
326 Execute (disable conceal):
327   if has('conceal')
328     let g:vim_markdown_conceal=0
329     syn off | syn on
330     setlocal conceallevel=2
331     AssertEqual synconcealed(1, 1)[0], 0
332     AssertEqual synconcealed(1, 2)[0], 0
333     AssertEqual synconcealed(1, 3)[0], 0
334     AssertEqual synconcealed(1, 4)[0], 0
335     AssertEqual synconcealed(1, 5)[0], 0
336     AssertEqual synconcealed(1, 6)[0], 0
337     AssertEqual synconcealed(1, 7)[0], 0
338
339     let g:vim_markdown_conceal=1
340     syn off | syn on
341     AssertEqual synconcealed(1, 1)[0], 1
342     AssertEqual synconcealed(1, 2)[0], 1
343     AssertEqual synconcealed(1, 3)[0], 1
344     AssertEqual synconcealed(1, 4)[0], 0
345     AssertEqual synconcealed(1, 5)[0], 1
346     AssertEqual synconcealed(1, 6)[0], 1
347     AssertEqual synconcealed(1, 7)[0], 1
348
349     setlocal conceallevel=0
350     unlet g:vim_markdown_conceal
351     syn off | syn on
352   endif
353
354 Given markdown;
355 ***a***
356
357 Execute (conceal italic bold):
358   if has('conceal')
359     setlocal conceallevel=2
360     AssertEqual synconcealed(1, 1)[0], 1
361     AssertEqual synconcealed(1, 2)[0], 1
362     AssertEqual synconcealed(1, 3)[0], 1
363     AssertEqual synconcealed(1, 4)[0], 0
364     AssertEqual synconcealed(1, 5)[0], 1
365     AssertEqual synconcealed(1, 6)[0], 1
366     AssertEqual synconcealed(1, 7)[0], 1
367     setlocal conceallevel=0
368   endif
369
370 Execute (disable conceal):
371   if has('conceal')
372     let g:vim_markdown_conceal=0
373     syn off | syn on
374     setlocal conceallevel=2
375     AssertEqual synconcealed(1, 1)[0], 0
376     AssertEqual synconcealed(1, 2)[0], 0
377     AssertEqual synconcealed(1, 3)[0], 0
378     AssertEqual synconcealed(1, 4)[0], 0
379     AssertEqual synconcealed(1, 5)[0], 0
380     AssertEqual synconcealed(1, 6)[0], 0
381     AssertEqual synconcealed(1, 7)[0], 0
382
383     let g:vim_markdown_conceal=1
384     syn off | syn on
385     AssertEqual synconcealed(1, 1)[0], 1
386     AssertEqual synconcealed(1, 2)[0], 1
387     AssertEqual synconcealed(1, 3)[0], 1
388     AssertEqual synconcealed(1, 4)[0], 0
389     AssertEqual synconcealed(1, 5)[0], 1
390     AssertEqual synconcealed(1, 6)[0], 1
391     AssertEqual synconcealed(1, 7)[0], 1
392
393     setlocal conceallevel=0
394     unlet g:vim_markdown_conceal
395     syn off | syn on
396   endif
397
398 # Links
399
400 Given markdown;
401 [a](b)
402
403 Execute (link with title):
404   AssertEqual SyntaxOf('a'), 'mkdLink'
405   AssertEqual SyntaxOf('b'), 'mkdURL'
406
407 Given markdown;
408 [a
409 b](c)
410
411 Execute (link text with newline):
412   AssertEqual SyntaxOf('a'), 'mkdLink'
413   AssertEqual SyntaxOf('b'), 'mkdLink'
414   AssertEqual SyntaxOf('c'), 'mkdURL'
415
416 Given markdown;
417 (a)
418
419 (b)
420
421 Execute (parenthesis not in link):
422   AssertNotEqual SyntaxOf('a'), 'mkdURL'
423   AssertNotEqual SyntaxOf('b'), 'mkdURL'
424
425 Given markdown;
426 [a](b) c [d](e)
427
428 Execute (multiple links on a line):
429   AssertNotEqual SyntaxOf('c'), 'mkdLink'
430   AssertNotEqual SyntaxOf('c'), 'mkdURL'
431
432 Given markdown;
433 [a] (b)
434
435 Execute (space is not allowed between link text and parenthesis):
436   AssertNotEqual SyntaxOf('a'), 'mkdLink'
437   AssertNotEqual SyntaxOf('b'), 'mkdURL'
438
439 Given markdown;
440 [a](b)
441
442 Execute (conceal link):
443   if has('conceal')
444     setlocal conceallevel=2
445     AssertEqual synconcealed(1, 1)[0], 1
446     AssertEqual synconcealed(1, 2)[0], 0
447     AssertEqual synconcealed(1, 3)[0], 1
448     AssertEqual synconcealed(1, 4)[0], 1
449     AssertEqual synconcealed(1, 4)[0], 1
450     AssertEqual synconcealed(1, 5)[0], 1
451     AssertEqual synconcealed(1, 6)[0], 1
452     setlocal conceallevel=0
453   endif
454
455 Execute (disable conceal):
456   if has('conceal')
457     let g:vim_markdown_conceal=0
458     syn off | syn on
459     setlocal conceallevel=2
460     AssertEqual synconcealed(1, 1)[0], 0
461     AssertEqual synconcealed(1, 2)[0], 0
462     AssertEqual synconcealed(1, 3)[0], 0
463     AssertEqual synconcealed(1, 4)[0], 0
464     AssertEqual synconcealed(1, 4)[0], 0
465     AssertEqual synconcealed(1, 5)[0], 0
466     AssertEqual synconcealed(1, 6)[0], 0
467
468     let g:vim_markdown_conceal=1
469     syn off | syn on
470     AssertEqual synconcealed(1, 1)[0], 1
471     AssertEqual synconcealed(1, 2)[0], 0
472     AssertEqual synconcealed(1, 3)[0], 1
473     AssertEqual synconcealed(1, 4)[0], 1
474     AssertEqual synconcealed(1, 4)[0], 1
475     AssertEqual synconcealed(1, 5)[0], 1
476     AssertEqual synconcealed(1, 6)[0], 1
477
478     setlocal conceallevel=0
479     unlet g:vim_markdown_conceal
480     syn off | syn on
481   endif
482
483 # Autolinks
484
485 Given markdown;
486 a <http://b> c
487
488 Execute (autolink):
489   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
490   AssertEqual SyntaxOf('<'), 'mkdDelimiter'
491   AssertEqual SyntaxOf('b'), 'mkdInlineURL'
492   AssertEqual SyntaxOf('>'), 'mkdDelimiter'
493   AssertNotEqual SyntaxOf('c'), 'mkdInlineURL'
494
495 Given markdown;
496 http://12monkeys.foo
497
498 Execute (autolink with domain starting with a number):
499   AssertEqual SyntaxOf('12monkeys'), 'mkdInlineURL'
500
501 Given markdown;
502 <HtTp://a>
503
504 Execute (autolink with scheme case is insensitive):
505   AssertEqual SyntaxOf('a'), 'mkdInlineURL'
506
507 Given markdown;
508 <a>
509
510 Execute (autolink without scheme is not a link):
511   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
512
513 Given markdown;
514 < http://a >
515 <http://b c>
516 <http://d
517 e>
518
519 Execute (autolink with space is not a link):
520   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
521   AssertNotEqual SyntaxOf('b'), 'mkdInlineURL'
522   AssertNotEqual SyntaxOf('c'), 'mkdInlineURL'
523   AssertNotEqual SyntaxOf('d'), 'mkdInlineURL'
524   AssertNotEqual SyntaxOf('e'), 'mkdInlineURL'
525
526 Given markdown;
527 \<http://a>
528
529 Execute (autolinks can be backslash escaped):
530   AssertNotEqual SyntaxOf('<'), 'mkdDelimiter'
531
532 Given markdown;
533 a (http://b.bb) c
534
535 Execute (autolink in parenthesis):
536   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
537   AssertEqual SyntaxOf('('), 'mkdDelimiter'
538   AssertEqual SyntaxOf('b'), 'mkdInlineURL'
539   AssertEqual SyntaxOf(')'), 'mkdDelimiter'
540   AssertNotEqual SyntaxOf('c'), 'mkdInlineURL'
541
542 Given markdown;
543 [![a](http://b)](http://c)
544
545 Execute (autolink in link text):
546   AssertEqual SyntaxOf('!'), 'mkdDelimiter'
547   AssertEqual SyntaxOf('a'), 'mkdLink'
548   AssertEqual SyntaxOf('b'), 'mkdURL'
549   AssertEqual SyntaxOf('c'), 'mkdURL'
550
551 Given markdown;
552 # [h1link](url)
553
554 ## [h2link](url)
555
556 ### [h3link](url)
557
558 #### [h4link](url)
559
560 ##### [h5link](url)
561
562 ###### [h6link](url)
563
564 [h1link_b](url)
565 ===============
566
567 [h2link_b](url)
568 ---------------
569
570 Execute (link in headers):
571   AssertEqual SyntaxOf('h1link'), 'mkdLink'
572   AssertEqual SyntaxOf('h2link'), 'mkdLink'
573   AssertEqual SyntaxOf('h3link'), 'mkdLink'
574   AssertEqual SyntaxOf('h4link'), 'mkdLink'
575   AssertEqual SyntaxOf('h5link'), 'mkdLink'
576   AssertEqual SyntaxOf('h6link'), 'mkdLink'
577   AssertEqual SyntaxOf('h1link_b'), 'mkdLink'
578   AssertEqual SyntaxOf('h2link_b'), 'mkdLink'
579
580 Given markdown;
581 # http://h1link.foo
582
583 ## http://h2link.foo
584
585 ### http://h3link.foo
586
587 #### http://h4link.foo
588
589 ##### http://h5link.foo
590
591 ###### http://h6link.foo
592
593 http://h1link_b.foo
594 ===================
595
596 http://h2link_b.foo
597 -------------------
598
599 Execute (inline url in headers):
600   AssertEqual SyntaxOf('h1link'), 'mkdInlineURL'
601   AssertEqual SyntaxOf('h2link'), 'mkdInlineURL'
602   AssertEqual SyntaxOf('h3link'), 'mkdInlineURL'
603   AssertEqual SyntaxOf('h4link'), 'mkdInlineURL'
604   AssertEqual SyntaxOf('h5link'), 'mkdInlineURL'
605   AssertEqual SyntaxOf('h6link'), 'mkdInlineURL'
606   AssertEqual SyntaxOf('h1link_b'), 'mkdInlineURL'
607   AssertEqual SyntaxOf('h2link_b'), 'mkdInlineURL'
608
609 Given markdown;
610 > [a](b)
611 > http://foo.bar
612
613 Execute (link in blockquote):
614   AssertEqual SyntaxOf('a'), 'mkdLink'
615   AssertEqual SyntaxOf('foo'), 'mkdInlineURL'
616
617 # Code Blocks
618
619 Given markdown;
620 ~~~
621 code
622 ~~~
623
624 Execute (code blocks can be fenced with tildes):
625   AssertEqual SyntaxOf('c'), 'mkdCode'
626
627 Given markdown;
628 ~~~~
629 code
630 ~~~~~
631
632 Execute (code blocks can be fenced with tildes longer than 3):
633   AssertEqual SyntaxOf('c'), 'mkdCode'
634
635 Given markdown;
636 ````
637 code
638 `````
639
640 Execute (code blocks can be fenced with backticks longer than 3):
641   AssertEqual SyntaxOf('c'), 'mkdCode'
642
643 Given markdown;
644 ~~~ruby
645 code
646 ~~~
647
648 Execute (code blocks can have a language specifier):
649   AssertEqual SyntaxOf('c'), 'mkdCode'
650
651 Given markdown;
652 ```c++
653 code
654 ```
655
656 text
657
658 Execute (code blocks can be fenced with backticks and a language specifier):
659   AssertEqual SyntaxOf('code'), 'mkdCode'
660   AssertNotEqual SyntaxOf('text'), 'mkdCode'
661
662 # Indent Code Blocks
663
664 Given markdown;
665 a
666
667     b
668     c
669
670 Execute (indent code blocks):
671   AssertNotEqual SyntaxOf('a'), 'mkdCode'
672   AssertEqual SyntaxOf('b'), 'mkdCode'
673   AssertEqual SyntaxOf('c'), 'mkdCode'
674
675 Given markdown;
676 # a
677
678 b
679
680     c
681
682 Execute (indent code blocks after header):
683   AssertNotEqual SyntaxOf('a'), 'mkdCode'
684   AssertNotEqual SyntaxOf('b'), 'mkdCode'
685   AssertEqual SyntaxOf('c'), 'mkdCode'
686
687 Given markdown;
688 -   a
689
690     b
691
692         c
693
694 Execute (indent code blocks after list):
695   AssertNotEqual SyntaxOf('a'), 'mkdCode'
696   AssertNotEqual SyntaxOf('b'), 'mkdCode'
697   AssertEqual SyntaxOf('c'), 'mkdCode'
698
699 Given markdown;
700     a
701     b
702
703 Execute (indent code block at beginning of file):
704   AssertEqual SyntaxOf('a'), 'mkdCode'
705   AssertEqual SyntaxOf('b'), 'mkdCode'
706
707 Given markdown;
708 ```c++
709 #include <iostream>
710 code
711 ```
712
713 ```ruby
714 def a
715 end
716 ```
717
718 Execute (fenced code block syntax with a language specifier):
719   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
720   call b:func(0)
721   AssertEqual SyntaxOf('include'), 'cInclude'
722   AssertEqual SyntaxOf('code'), 'mkdSnippetCPP'
723   AssertEqual SyntaxOf('def'), 'rubyDefine'
724
725 Given markdown;
726 ``` c++
727 #include <iostream>
728 code
729 ```
730
731 ```  vim
732 let g:a = 1
733 ```
734
735 ```     ruby
736 def a
737 end
738 ```
739
740 ```
741 ruby
742 class B
743 end
744 ```
745
746 Execute (fenced code block syntax with a language specifier after whitespace):
747   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
748   call b:func(0)
749   AssertEqual SyntaxOf('include'), 'cInclude'
750   AssertEqual SyntaxOf('code'), 'mkdSnippetCPP'
751   AssertEqual SyntaxOf('g:a'), 'vimVar'
752   AssertEqual SyntaxOf('def'), 'rubyDefine'
753   AssertNotEqual SyntaxOf('class'), 'rubyClass'
754
755 Given markdown;
756 ```vim
757 let g:a = 1
758 ```
759
760 ```viml
761 let g:b = 1
762 ```
763
764 Execute (fenced code block syntax with alias language specifier):
765   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
766   call b:func(0)
767   AssertEqual SyntaxOf('g:a'), 'vimVar'
768   AssertEqual SyntaxOf('g:b'), 'vimVar'
769
770 Given markdown;
771 ```csharp
772 var s = "foo";
773 ```
774
775 Execute (fenced code block languages setting):
776   let g:vim_markdown_fenced_languages = ['csharp=cs']
777   source ../ftplugin/markdown.vim
778   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
779   call b:func(0)
780   AssertEqual SyntaxOf('foo'), 'csString'
781   unlet g:vim_markdown_fenced_languages
782
783 Given markdown;
784 ```vim
785 let g:a = 1
786 ```
787
788 Execute (fenced code block includes language syntax with reopening same buffer):
789   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
790   call b:func(0)
791   split
792   quit
793   edit
794   set filetype=markdown
795   execute "normal! i```vim\<cr>let g:a = 1\<cr>```"
796   call b:func(1)
797   AssertEqual SyntaxOf('g:a'), 'vimVar'
798
799 Given markdown;
800 ```a+b-
801 code
802 ```
803
804 Execute (fenced code block syntax with an unknown language specifier):
805   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
806   call b:func(0)
807   AssertEqual SyntaxOf('code'), 'mkdSnippetA_B_'
808
809 Given markdown;
810 ```
811 =
812 a
813 -
814 ```
815
816 Execute (first = or - in fenced code block is not setex headers):
817   AssertEqual SyntaxOf('='), 'mkdCode'
818   AssertEqual SyntaxOf('-'), 'mkdCode'
819
820 Given markdown;
821 ``` {style=""}
822 a
823 ```
824
825 Execute (fenced code block with extended info strings):
826   AssertEqual SyntaxOf('a'), 'mkdCode'
827
828 # Code Blocks in pre and code tag
829
830 Given markdown;
831 <pre>
832 a
833 </pre>
834
835 Execute (code block in pre tag):
836   AssertEqual SyntaxOf('a'), 'mkdCode'
837
838 Given markdown;
839 <code>
840 a
841 </code>
842
843 Execute (code block in code tag):
844   AssertEqual SyntaxOf('a'), 'mkdCode'
845
846 Given markdown;
847 \<pre\>
848 a
849 \</pre\>
850
851 Execute (not code block in escaped pre tag):
852   AssertNotEqual SyntaxOf('a'), 'mkdCode'
853
854 Given markdown;
855 \<code\>
856 a
857 \</code\>
858
859 Execute (not code block in escaped code tag):
860   AssertNotEqual SyntaxOf('a'), 'mkdCode'
861
862 # Math
863
864 Given markdown;
865 a $x$ b
866 c $$y$$ d
867 \$e\$
868 \$\$f\$\$
869
870 Execute (math):
871   AssertNotEqual SyntaxOf('x')[0:2], 'tex'
872   AssertNotEqual SyntaxOf('y')[0:2], 'tex'
873   let g:vim_markdown_math=1
874   syn off | syn on
875   AssertNotEqual SyntaxOf('a')[0:2], 'tex'
876   AssertNotEqual SyntaxOf('b')[0:2], 'tex'
877   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
878   AssertNotEqual SyntaxOf('d')[0:2], 'tex'
879   AssertNotEqual SyntaxOf('e')[0:2], 'tex'
880   AssertNotEqual SyntaxOf('f')[0:2], 'tex'
881   AssertEqual SyntaxOf('x')[0:2], 'tex'
882   AssertEqual SyntaxOf('y')[0:2], 'tex'
883   let g:vim_markdown_math=0
884   syn off | syn on
885   AssertNotEqual SyntaxOf('x')[0:2], 'tex'
886   AssertNotEqual SyntaxOf('y')[0:2], 'tex'
887
888 Given markdown;
889 a
890
891 $
892 b
893 $
894
895 c
896
897 Execute (multiline math):
898   let g:vim_markdown_math=1
899   syn off | syn on
900   AssertNotEqual SyntaxOf('a')[0:2], 'tex'
901   AssertEqual SyntaxOf('b')[0:2], 'tex'
902   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
903
904 Given markdown;
905 $ \sqrt{a}{b} $
906 $$ \frac{a}{b} $$
907
908 Execute (math tex highlighting):
909   let g:vim_markdown_math=0
910   syn off | syn on
911   AssertNotEqual SyntaxOf('sqrt'), 'texStatement'
912   AssertNotEqual SyntaxOf('frac'), 'texStatement'
913   let g:vim_markdown_math=1
914   syn off | syn on
915   AssertEqual SyntaxOf('sqrt'), 'texStatement'
916   AssertEqual SyntaxOf('frac'), 'texStatement'
917
918 Given markdown;
919 $a b[$ c
920
921 Execute (math ends with $):
922   let g:vim_markdown_math=1
923   syn off | syn on
924   AssertEqual SyntaxOf('a')[0:2], 'tex'
925   AssertEqual SyntaxOf('b')[0:2], 'tex'
926   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
927
928 Given markdown;
929 $$a b[$$ c
930
931 Execute (math ends with $$):
932   let g:vim_markdown_math=1
933   syn off | syn on
934   AssertEqual SyntaxOf('a')[0:2], 'tex'
935   AssertEqual SyntaxOf('b')[0:2], 'tex'
936   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
937
938 Given markdown;
939 $(0 \le 1)$
940
941 Execute (math conceal in $):
942   if has('conceal')
943     setlocal conceallevel=2
944     let g:vim_markdown_math=1
945     syn off | syn on
946     AssertEqual synconcealed(1, 1)[0], 1, '$'
947     AssertEqual synconcealed(1, 2)[0], 0
948     AssertEqual synconcealed(1, 3)[0], 0
949     AssertEqual synconcealed(1, 4)[0], 0
950     AssertEqual synconcealed(1, 5)[0], 1, '\le'
951     AssertEqual synconcealed(1, 6)[0], 1
952     AssertEqual synconcealed(1, 7)[0], 1
953     AssertEqual synconcealed(1, 8)[0], 0
954     AssertEqual synconcealed(1, 9)[0], 0
955     AssertEqual synconcealed(1, 10)[0], 0
956     AssertEqual synconcealed(1, 11)[0], 1, '$'
957     setlocal conceallevel=0
958   endif
959
960 Given markdown;
961 $$
962 \omega
963 0 \le 1
964 $$
965
966 Execute (math conceal in $$):
967   if has('conceal')
968     setlocal conceallevel=2
969     let g:vim_markdown_math=1
970     syn off | syn on
971     AssertEqual synconcealed(1, 1)[0], 1, '$$'
972     AssertEqual synconcealed(2, 1)[0], 1, '\omega'
973     AssertEqual synconcealed(3, 1)[0], 0, '0'
974     AssertEqual synconcealed(3, 3)[0], 1, '\le'
975     AssertEqual synconcealed(3, 7)[0], 0, '1'
976     AssertEqual synconcealed(4, 1)[0], 1, '$$'
977     setlocal conceallevel=0
978   endif
979
980 # YAML frontmatter
981
982 Given markdown;
983 ---
984 a: b
985 ---
986
987 Execute (YAML frontmatter is controlled by the option):
988   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
989   let g:vim_markdown_frontmatter=1
990   syn off | syn on
991   AssertEqual SyntaxOf('a')[0:3], 'yaml'
992   let g:vim_markdown_frontmatter=0
993   syn off | syn on
994   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
995
996 Given markdown;
997
998 ---
999 a: b
1000 ---
1001
1002 Execute (YAML frontmatter only works if it's the first thing in the file):
1003   let g:vim_markdown_frontmatter=1
1004   syn off | syn on
1005   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
1006
1007 Given markdown;
1008 ---
1009 a: b
1010 ---
1011
1012 ---
1013
1014 Execute (rules are not mistaken by YAML frontmatter delimiters):
1015   let g:vim_markdown_frontmatter=1
1016   syn off | syn on
1017   AssertEqual SyntaxAt(5, 1), 'mkdRule'
1018   unlet g:vim_markdown_frontmatter
1019
1020 # TOML frontmatter
1021
1022 Given markdown;
1023 +++
1024 a = "b"
1025 +++
1026
1027 Execute (TOML frontmatter is controlled by the option):
1028   syn off | syn on
1029   AssertNotEqual SyntaxOf('b'), 'tomlString'
1030   let g:vim_markdown_toml_frontmatter=1
1031   syn off | syn on
1032   AssertEqual SyntaxOf('b'), 'tomlString'
1033   let g:vim_markdown_toml_frontmatter=0
1034   syn off | syn on
1035   AssertNotEqual SyntaxOf('b'), 'tomlString'
1036
1037 Given markdown;
1038
1039 +++
1040 a = "b"
1041 +++
1042
1043 Execute (TOML frontmatter only works if it's the first thing in the file):
1044   let g:vim_markdown_toml_frontmatter=1
1045   syn off | syn on
1046   AssertNotEqual SyntaxOf('b'), 'tomlString'
1047   unlet g:vim_markdown_toml_frontmatter
1048
1049 # JSON frontmatter
1050
1051 Given markdown;
1052 {
1053   "a": "b"
1054 }
1055
1056 Execute (JSON frontmatter is controlled by the option):
1057   syn off | syn on
1058   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
1059   let g:vim_markdown_json_frontmatter=1
1060   syn off | syn on
1061   AssertEqual SyntaxOf('a'), 'jsonKeyword'
1062   let g:vim_markdown_json_frontmatter=0
1063   syn off | syn on
1064   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
1065
1066 Given markdown;
1067
1068 {
1069   "a": "b"
1070 }
1071
1072 Execute (JSON frontmatter only works if it's the first thing in the file):
1073   let g:vim_markdown_json_frontmatter=1
1074   syn off | syn on
1075   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
1076   unlet g:vim_markdown_json_frontmatter
1077
1078 # Header
1079
1080 Given markdown;
1081 # #a
1082 ccc
1083
1084 ## #b
1085 ddd
1086
1087 Execute (header title starts with #):
1088   AssertEqual SyntaxOf('a'), 'htmlH1'
1089   AssertEqual SyntaxOf('b'), 'htmlH2'
1090
1091 Given markdown;
1092 # h1 space
1093
1094 #h1 nospace
1095
1096 #  h1 2 spaces
1097
1098 # h1 trailing hash #
1099
1100 ## h2 space
1101
1102 ##h2 nospace
1103
1104 ## h2 trailing hash ##
1105
1106 ### h3 space
1107
1108 ###h3 nospace
1109
1110 ### h3 trailing hash ###
1111
1112 #### h4
1113
1114 ##### h5
1115
1116 ###### h6
1117
1118 Execute (atx headers):
1119   AssertEqual SyntaxOf('# h1 space'), 'htmlH1'
1120   AssertEqual SyntaxOf('#h1 nospace'), 'htmlH1'
1121   AssertEqual SyntaxOf('#  h1 2 spaces'), 'htmlH1'
1122   AssertEqual SyntaxOf('# h1 trailing hash #'), 'htmlH1'
1123   AssertEqual SyntaxOf('## h2 space'), 'htmlH2'
1124   AssertEqual SyntaxOf('##h2 nospace'), 'htmlH2'
1125   AssertEqual SyntaxOf('## h2 trailing hash ##'), 'htmlH2'
1126   AssertEqual SyntaxOf('### h3 space'), 'htmlH3'
1127   AssertEqual SyntaxOf('###h3 nospace'), 'htmlH3'
1128   AssertEqual SyntaxOf('### h3 trailing hash ###'), 'htmlH3'
1129   AssertEqual SyntaxOf('#### h4'), 'htmlH4'
1130   AssertEqual SyntaxOf('##### h5'), 'htmlH5'
1131   AssertEqual SyntaxOf('###### h6'), 'htmlH6'
1132
1133 Given markdown;
1134 # h1 before h2
1135
1136 ## h2 between h1s
1137
1138 # h1 after h2
1139
1140 Execute (atx headers relative positions):
1141   AssertEqual SyntaxOf('# h1 before h2'), 'htmlH1'
1142   AssertEqual SyntaxOf('## h2 between h1s'), 'htmlH2'
1143   AssertEqual SyntaxOf('# h1 after h2'), 'htmlH1'
1144
1145 Given markdown;
1146 setex h1
1147 ========
1148
1149 setex h2
1150 --------
1151
1152 setex h1 single punctuation
1153 =
1154
1155 setex h1 punctuation longer than header
1156 ================================
1157
1158 Execute (setex headers):
1159   AssertEqual SyntaxOf('setex h1'), 'htmlH1'
1160   AssertEqual SyntaxOf('^========$'), 'htmlH1'
1161   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
1162   AssertEqual SyntaxOf('--------'), 'htmlH2'
1163   AssertEqual SyntaxOf('setex h1 single punctuation'), 'htmlH1'
1164   AssertEqual SyntaxOf('^=$'), 'htmlH1'
1165   AssertEqual SyntaxOf('setex h1 punctuation longer than header'), 'htmlH1'
1166   AssertEqual SyntaxOf('^================================$'), 'htmlH1'
1167
1168 Given markdown;
1169 - not Setex
1170 - because list
1171
1172 Execute (prevent list vs Setex confusion):
1173   AssertNotEqual SyntaxOf('- not Setex'), 'htmlH2'
1174   AssertNotEqual SyntaxOf('- becuase list'), 'htmlH2'
1175
1176 Given markdown;
1177 setex h1 before atx
1178 ===================
1179
1180 ## atx h2
1181
1182 ### atx h3
1183
1184 # atx h1
1185
1186 setex h2
1187 ------------------
1188
1189 ### atx h3 2
1190
1191 Execute (mixed atx and setex headers):
1192   AssertEqual SyntaxOf('setex h1 before atx'), 'htmlH1'
1193   AssertEqual SyntaxOf('==================='), 'htmlH1'
1194   AssertEqual SyntaxOf('## atx h2'), 'htmlH2'
1195   AssertEqual SyntaxOf('### atx h3'), 'htmlH3'
1196   AssertEqual SyntaxOf('# atx h1'), 'htmlH1'
1197   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
1198   AssertEqual SyntaxOf('------------------'), 'htmlH2'
1199
1200 # List
1201
1202 Given markdown;
1203 - a & b
1204 1. c > d
1205
1206 Execute (& and > are not marked as htmlError in lists):
1207   AssertEqual SyntaxOf('-'), 'mkdListItem'
1208   AssertEqual SyntaxOf('1.'), 'mkdListItem'
1209   AssertNotEqual SyntaxOf('&'), 'htmlError'
1210   AssertNotEqual SyntaxOf('>'), 'htmlError'
1211
1212 Given markdown;
1213 1. a  
1214 2. b
1215
1216 Execute (list after line break):
1217   AssertEqual SyntaxOf('1'), 'mkdListItem'
1218   AssertEqual SyntaxOf('2'), 'mkdListItem'
1219
1220 # HTML
1221
1222 Given markdown;
1223 a
1224
1225 <p>b</p>
1226
1227 - <span>c</span>
1228
1229 Execute (HTML tag in text):
1230   AssertEqual SyntaxOf('p'), 'htmlTagName'
1231   AssertEqual SyntaxOf('<p>'), 'htmlTag'
1232   AssertEqual SyntaxOf('</p>'), 'htmlEndTag'
1233   AssertEqual SyntaxOf('span'), 'htmlTagName'
1234   AssertEqual SyntaxOf('<span>'), 'htmlTag'
1235   AssertEqual SyntaxOf('</span>'), 'htmlEndTag'