]> 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:

Add support for another extension
[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] b [c](d)
418
419 Execute (link text with bracket sections):
420   AssertNotEqual SyntaxOf('a'), 'mkdLink'
421   AssertNotEqual SyntaxOf('b'), 'mkdLink'
422   AssertEqual SyntaxOf('c'), 'mkdLink'
423   AssertEqual SyntaxOf('d'), 'mkdURL'
424
425 Given markdown;
426 [^a]: b
427
428 Execute (footnote is not link):
429   AssertNotEqual SyntaxOf('a'), 'mkdLinkDef'
430
431 Given markdown;
432 (a)
433
434 (b)
435
436 Execute (parenthesis not in link):
437   AssertNotEqual SyntaxOf('a'), 'mkdURL'
438   AssertNotEqual SyntaxOf('b'), 'mkdURL'
439
440 Given markdown;
441 [a](b) c [d](e)
442
443 Execute (multiple links on a line):
444   AssertNotEqual SyntaxOf('c'), 'mkdLink'
445   AssertNotEqual SyntaxOf('c'), 'mkdURL'
446
447 Given markdown;
448 [a] (b)
449
450 Execute (space is not allowed between link text and parenthesis):
451   AssertNotEqual SyntaxOf('a'), 'mkdLink'
452   AssertNotEqual SyntaxOf('b'), 'mkdURL'
453
454 Given markdown;
455 [a](b)
456
457 Execute (conceal link):
458   if has('conceal')
459     setlocal conceallevel=2
460     AssertEqual synconcealed(1, 1)[0], 1
461     AssertEqual synconcealed(1, 2)[0], 0
462     AssertEqual synconcealed(1, 3)[0], 1
463     AssertEqual synconcealed(1, 4)[0], 1
464     AssertEqual synconcealed(1, 4)[0], 1
465     AssertEqual synconcealed(1, 5)[0], 1
466     AssertEqual synconcealed(1, 6)[0], 1
467     setlocal conceallevel=0
468   endif
469
470 Execute (disable conceal):
471   if has('conceal')
472     let g:vim_markdown_conceal=0
473     syn off | syn on
474     setlocal conceallevel=2
475     AssertEqual synconcealed(1, 1)[0], 0
476     AssertEqual synconcealed(1, 2)[0], 0
477     AssertEqual synconcealed(1, 3)[0], 0
478     AssertEqual synconcealed(1, 4)[0], 0
479     AssertEqual synconcealed(1, 4)[0], 0
480     AssertEqual synconcealed(1, 5)[0], 0
481     AssertEqual synconcealed(1, 6)[0], 0
482
483     let g:vim_markdown_conceal=1
484     syn off | syn on
485     AssertEqual synconcealed(1, 1)[0], 1
486     AssertEqual synconcealed(1, 2)[0], 0
487     AssertEqual synconcealed(1, 3)[0], 1
488     AssertEqual synconcealed(1, 4)[0], 1
489     AssertEqual synconcealed(1, 4)[0], 1
490     AssertEqual synconcealed(1, 5)[0], 1
491     AssertEqual synconcealed(1, 6)[0], 1
492
493     setlocal conceallevel=0
494     unlet g:vim_markdown_conceal
495     syn off | syn on
496   endif
497
498 # Autolinks
499
500 Given markdown;
501 a <http://b> c
502
503 Execute (autolink):
504   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
505   AssertEqual SyntaxOf('<'), 'mkdDelimiter'
506   AssertEqual SyntaxOf('b'), 'mkdInlineURL'
507   AssertEqual SyntaxOf('>'), 'mkdDelimiter'
508   AssertNotEqual SyntaxOf('c'), 'mkdInlineURL'
509
510 Given markdown;
511 http://12monkeys.foo
512
513 Execute (autolink with domain starting with a number):
514   AssertEqual SyntaxOf('12monkeys'), 'mkdInlineURL'
515
516 Given markdown;
517 <HtTp://a>
518
519 Execute (autolink with scheme case is insensitive):
520   AssertEqual SyntaxOf('a'), 'mkdInlineURL'
521
522 Given markdown;
523 <a>
524
525 Execute (autolink without scheme is not a link):
526   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
527
528 Given markdown;
529 < http://a >
530 <http://b c>
531 <http://d
532 e>
533
534 Execute (autolink with space is not a link):
535   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
536   AssertNotEqual SyntaxOf('b'), 'mkdInlineURL'
537   AssertNotEqual SyntaxOf('c'), 'mkdInlineURL'
538   AssertNotEqual SyntaxOf('d'), 'mkdInlineURL'
539   AssertNotEqual SyntaxOf('e'), 'mkdInlineURL'
540
541 Given markdown;
542 \<http://a>
543
544 Execute (autolinks can be backslash escaped):
545   AssertNotEqual SyntaxOf('<'), 'mkdDelimiter'
546
547 Given markdown;
548 a (http://b.bb) c
549
550 Execute (autolink in parenthesis):
551   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
552   AssertEqual SyntaxOf('('), 'mkdDelimiter'
553   AssertEqual SyntaxOf('b'), 'mkdInlineURL'
554   AssertEqual SyntaxOf(')'), 'mkdDelimiter'
555   AssertNotEqual SyntaxOf('c'), 'mkdInlineURL'
556
557 Given markdown;
558 [![a](http://b)](http://c)
559
560 Execute (autolink in link text):
561   AssertEqual SyntaxOf('!'), 'mkdDelimiter'
562   AssertEqual SyntaxOf('a'), 'mkdLink'
563   AssertEqual SyntaxOf('b'), 'mkdURL'
564   AssertEqual SyntaxOf('c'), 'mkdURL'
565
566 Given markdown;
567 # [h1link](url)
568
569 ## [h2link](url)
570
571 ### [h3link](url)
572
573 #### [h4link](url)
574
575 ##### [h5link](url)
576
577 ###### [h6link](url)
578
579 [h1link_b](url)
580 ===============
581
582 [h2link_b](url)
583 ---------------
584
585 Execute (link in headers):
586   AssertEqual SyntaxOf('h1link'), 'mkdLink'
587   AssertEqual SyntaxOf('h2link'), 'mkdLink'
588   AssertEqual SyntaxOf('h3link'), 'mkdLink'
589   AssertEqual SyntaxOf('h4link'), 'mkdLink'
590   AssertEqual SyntaxOf('h5link'), 'mkdLink'
591   AssertEqual SyntaxOf('h6link'), 'mkdLink'
592   AssertEqual SyntaxOf('h1link_b'), 'mkdLink'
593   AssertEqual SyntaxOf('h2link_b'), 'mkdLink'
594
595 Given markdown;
596 # http://h1link.foo
597
598 ## http://h2link.foo
599
600 ### http://h3link.foo
601
602 #### http://h4link.foo
603
604 ##### http://h5link.foo
605
606 ###### http://h6link.foo
607
608 http://h1link_b.foo
609 ===================
610
611 http://h2link_b.foo
612 -------------------
613
614 Execute (inline url in headers):
615   AssertEqual SyntaxOf('h1link'), 'mkdInlineURL'
616   AssertEqual SyntaxOf('h2link'), 'mkdInlineURL'
617   AssertEqual SyntaxOf('h3link'), 'mkdInlineURL'
618   AssertEqual SyntaxOf('h4link'), 'mkdInlineURL'
619   AssertEqual SyntaxOf('h5link'), 'mkdInlineURL'
620   AssertEqual SyntaxOf('h6link'), 'mkdInlineURL'
621   AssertEqual SyntaxOf('h1link_b'), 'mkdInlineURL'
622   AssertEqual SyntaxOf('h2link_b'), 'mkdInlineURL'
623
624 Given markdown;
625 > [a](b)
626 > http://foo.bar
627
628 Execute (link in blockquote):
629   AssertEqual SyntaxOf('a'), 'mkdLink'
630   AssertEqual SyntaxOf('foo'), 'mkdInlineURL'
631
632 # Code Blocks
633
634 Given markdown;
635 ~~~
636 code
637 ~~~
638
639 Execute (code blocks can be fenced with tildes):
640   AssertEqual SyntaxOf('c'), 'mkdCode'
641
642 Given markdown;
643 ~~~~
644 code
645 ~~~~~
646
647 Execute (code blocks can be fenced with tildes longer than 3):
648   AssertEqual SyntaxOf('c'), 'mkdCode'
649
650 Given markdown;
651 ````
652 code
653 `````
654
655 Execute (code blocks can be fenced with backticks longer than 3):
656   AssertEqual SyntaxOf('c'), 'mkdCode'
657
658 Given markdown;
659 ~~~ruby
660 code
661 ~~~
662
663 Execute (code blocks can have a language specifier):
664   AssertEqual SyntaxOf('c'), 'mkdCode'
665
666 Given markdown;
667 ```c++
668 code
669 ```
670
671 text
672
673 Execute (code blocks can be fenced with backticks and a language specifier):
674   AssertEqual SyntaxOf('code'), 'mkdCode'
675   AssertNotEqual SyntaxOf('text'), 'mkdCode'
676
677 # Indent Code Blocks
678
679 Given markdown;
680 a
681
682     b
683     c
684
685 Execute (indent code blocks):
686   AssertNotEqual SyntaxOf('a'), 'mkdCode'
687   AssertEqual SyntaxOf('b'), 'mkdCode'
688   AssertEqual SyntaxOf('c'), 'mkdCode'
689
690 Given markdown;
691 # a
692
693 b
694
695     c
696
697 Execute (indent code blocks after header):
698   AssertNotEqual SyntaxOf('a'), 'mkdCode'
699   AssertNotEqual SyntaxOf('b'), 'mkdCode'
700   AssertEqual SyntaxOf('c'), 'mkdCode'
701
702 Given markdown;
703 -   a
704
705     b
706
707         c
708
709 Execute (indent code blocks after list):
710   AssertNotEqual SyntaxOf('a'), 'mkdCode'
711   AssertNotEqual SyntaxOf('b'), 'mkdCode'
712   AssertEqual SyntaxOf('c'), 'mkdCode'
713
714 Given markdown;
715     a
716     b
717
718 Execute (indent code block at beginning of file):
719   AssertEqual SyntaxOf('a'), 'mkdCode'
720   AssertEqual SyntaxOf('b'), 'mkdCode'
721
722 Given markdown;
723 ```c++
724 #include <iostream>
725 code
726 ```
727
728 ```ruby
729 def a
730 end
731 ```
732
733 Execute (fenced code block syntax with a language specifier):
734   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
735   call b:func(0)
736   AssertEqual SyntaxOf('include'), 'cInclude'
737   AssertEqual SyntaxOf('code'), 'mkdSnippetCPP'
738   AssertEqual SyntaxOf('def'), 'rubyDefine'
739
740 Given markdown;
741 ``` c++
742 #include <iostream>
743 code
744 ```
745
746 ```  vim
747 let g:a = 1
748 ```
749
750 ```     ruby
751 def a
752 end
753 ```
754
755 ```
756 ruby
757 class B
758 end
759 ```
760
761 Execute (fenced code block syntax with a language specifier after whitespace):
762   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
763   call b:func(0)
764   AssertEqual SyntaxOf('include'), 'cInclude'
765   AssertEqual SyntaxOf('code'), 'mkdSnippetCPP'
766   AssertEqual SyntaxOf('g:a'), 'vimVar'
767   AssertEqual SyntaxOf('def'), 'rubyDefine'
768   AssertNotEqual SyntaxOf('class'), 'rubyClass'
769
770 Given markdown;
771 ```vim
772 let g:a = 1
773 ```
774
775 ```viml
776 let g:b = 1
777 ```
778
779 Execute (fenced code block syntax with alias language specifier):
780   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
781   call b:func(0)
782   AssertEqual SyntaxOf('g:a'), 'vimVar'
783   AssertEqual SyntaxOf('g:b'), 'vimVar'
784
785 Given markdown;
786 ```csharp
787 var s = "foo";
788 ```
789
790 Execute (fenced code block languages setting):
791   let g:vim_markdown_fenced_languages = ['csharp=cs']
792   source ../ftplugin/markdown.vim
793   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
794   call b:func(0)
795   AssertEqual SyntaxOf('foo'), 'csString'
796   unlet g:vim_markdown_fenced_languages
797
798 Given markdown;
799 ```vim
800 let g:a = 1
801 ```
802
803 Execute (fenced code block includes language syntax with reopening same buffer):
804   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
805   call b:func(0)
806   split
807   quit
808   edit
809   set filetype=markdown
810   execute "normal! i```vim\<cr>let g:a = 1\<cr>```"
811   call b:func(1)
812   AssertEqual SyntaxOf('g:a'), 'vimVar'
813
814 Given markdown;
815 ```a+b-
816 code
817 ```
818
819 Execute (fenced code block syntax with an unknown language specifier):
820   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
821   call b:func(0)
822   AssertEqual SyntaxOf('code'), 'mkdSnippetA_B_'
823
824 Given markdown;
825 ```
826 =
827 a
828 -
829 ```
830
831 Execute (first = or - in fenced code block is not setex headers):
832   AssertEqual SyntaxOf('='), 'mkdCode'
833   AssertEqual SyntaxOf('-'), 'mkdCode'
834
835 Given markdown;
836 ``` {style=""}
837 a
838 ```
839
840 Execute (fenced code block with extended info strings):
841   AssertEqual SyntaxOf('a'), 'mkdCode'
842
843 # Code Blocks in pre and code tag
844
845 Given markdown;
846 <pre>
847 a
848 </pre>
849
850 Execute (code block in pre tag):
851   AssertEqual SyntaxOf('a'), 'mkdCode'
852
853 Given markdown;
854 <code>
855 a
856 </code>
857
858 Execute (code block in code tag):
859   AssertEqual SyntaxOf('a'), 'mkdCode'
860
861 Given markdown;
862 \<pre\>
863 a
864 \</pre\>
865
866 Execute (not code block in escaped pre tag):
867   AssertNotEqual SyntaxOf('a'), 'mkdCode'
868
869 Given markdown;
870 \<code\>
871 a
872 \</code\>
873
874 Execute (not code block in escaped code tag):
875   AssertNotEqual SyntaxOf('a'), 'mkdCode'
876
877 # Math
878
879 Given markdown;
880 a $x$ b
881 c $$y$$ d
882 \$e\$
883 \$\$f\$\$
884
885 Execute (math):
886   AssertNotEqual SyntaxOf('x')[0:2], 'tex'
887   AssertNotEqual SyntaxOf('y')[0:2], 'tex'
888   let g:vim_markdown_math=1
889   syn off | syn on
890   AssertNotEqual SyntaxOf('a')[0:2], 'tex'
891   AssertNotEqual SyntaxOf('b')[0:2], 'tex'
892   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
893   AssertNotEqual SyntaxOf('d')[0:2], 'tex'
894   AssertNotEqual SyntaxOf('e')[0:2], 'tex'
895   AssertNotEqual SyntaxOf('f')[0:2], 'tex'
896   AssertEqual SyntaxOf('x')[0:2], 'tex'
897   AssertEqual SyntaxOf('y')[0:2], 'tex'
898   let g:vim_markdown_math=0
899   syn off | syn on
900   AssertNotEqual SyntaxOf('x')[0:2], 'tex'
901   AssertNotEqual SyntaxOf('y')[0:2], 'tex'
902
903 Given markdown;
904 a
905
906 $
907 b
908 $
909
910 c
911
912 Execute (multiline math):
913   let g:vim_markdown_math=1
914   syn off | syn on
915   AssertNotEqual SyntaxOf('a')[0:2], 'tex'
916   AssertEqual SyntaxOf('b')[0:2], 'tex'
917   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
918
919 Given markdown;
920 $ \sqrt{a}{b} $
921 $$ \frac{a}{b} $$
922
923 Execute (math tex highlighting):
924   let g:vim_markdown_math=0
925   syn off | syn on
926   AssertNotEqual SyntaxOf('sqrt'), 'texStatement'
927   AssertNotEqual SyntaxOf('frac'), 'texStatement'
928   let g:vim_markdown_math=1
929   syn off | syn on
930   AssertEqual SyntaxOf('sqrt'), 'texStatement'
931   AssertEqual SyntaxOf('frac'), 'texStatement'
932
933 Given markdown;
934 $a b[$ c
935
936 Execute (math ends with $):
937   let g:vim_markdown_math=1
938   syn off | syn on
939   AssertEqual SyntaxOf('a')[0:2], 'tex'
940   AssertEqual SyntaxOf('b')[0:2], 'tex'
941   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
942
943 Given markdown;
944 $$a b[$$ c
945
946 Execute (math ends with $$):
947   let g:vim_markdown_math=1
948   syn off | syn on
949   AssertEqual SyntaxOf('a')[0:2], 'tex'
950   AssertEqual SyntaxOf('b')[0:2], 'tex'
951   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
952
953 Given markdown;
954 $(0 \le 1)$
955
956 Execute (math conceal in $):
957   if has('conceal')
958     setlocal conceallevel=2
959     let g:vim_markdown_math=1
960     syn off | syn on
961     AssertEqual synconcealed(1, 1)[0], 1, '$'
962     AssertEqual synconcealed(1, 2)[0], 0
963     AssertEqual synconcealed(1, 3)[0], 0
964     AssertEqual synconcealed(1, 4)[0], 0
965     AssertEqual synconcealed(1, 5)[0], 1, '\le'
966     AssertEqual synconcealed(1, 6)[0], 1
967     AssertEqual synconcealed(1, 7)[0], 1
968     AssertEqual synconcealed(1, 8)[0], 0
969     AssertEqual synconcealed(1, 9)[0], 0
970     AssertEqual synconcealed(1, 10)[0], 0
971     AssertEqual synconcealed(1, 11)[0], 1, '$'
972     setlocal conceallevel=0
973   endif
974
975 Given markdown;
976 $$
977 \omega
978 0 \le 1
979 $$
980
981 Execute (math conceal in $$):
982   if has('conceal')
983     setlocal conceallevel=2
984     let g:vim_markdown_math=1
985     syn off | syn on
986     AssertEqual synconcealed(1, 1)[0], 1, '$$'
987     AssertEqual synconcealed(2, 1)[0], 1, '\omega'
988     AssertEqual synconcealed(3, 1)[0], 0, '0'
989     AssertEqual synconcealed(3, 3)[0], 1, '\le'
990     AssertEqual synconcealed(3, 7)[0], 0, '1'
991     AssertEqual synconcealed(4, 1)[0], 1, '$$'
992     setlocal conceallevel=0
993   endif
994
995 # YAML frontmatter
996
997 Given markdown;
998 ---
999 a: b
1000 ---
1001
1002 Execute (YAML frontmatter is controlled by the option):
1003   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
1004   let g:vim_markdown_frontmatter=1
1005   syn off | syn on
1006   AssertEqual SyntaxOf('a')[0:3], 'yaml'
1007   let g:vim_markdown_frontmatter=0
1008   syn off | syn on
1009   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
1010
1011 Given markdown;
1012
1013 ---
1014 a: b
1015 ---
1016
1017 Execute (YAML frontmatter only works if it's the first thing in the file):
1018   let g:vim_markdown_frontmatter=1
1019   syn off | syn on
1020   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
1021
1022 Given markdown;
1023 ---
1024 a: b
1025 ---
1026
1027 ---
1028
1029 Execute (rules are not mistaken by YAML frontmatter delimiters):
1030   let g:vim_markdown_frontmatter=1
1031   syn off | syn on
1032   AssertEqual SyntaxAt(5, 1), 'mkdRule'
1033   unlet g:vim_markdown_frontmatter
1034
1035 # TOML frontmatter
1036
1037 Given markdown;
1038 +++
1039 a = "b"
1040 +++
1041
1042 Execute (TOML frontmatter is controlled by the option):
1043   syn off | syn on
1044   AssertNotEqual SyntaxOf('b'), 'tomlString'
1045   let g:vim_markdown_toml_frontmatter=1
1046   syn off | syn on
1047   AssertEqual SyntaxOf('b'), 'tomlString'
1048   let g:vim_markdown_toml_frontmatter=0
1049   syn off | syn on
1050   AssertNotEqual SyntaxOf('b'), 'tomlString'
1051
1052 Given markdown;
1053
1054 +++
1055 a = "b"
1056 +++
1057
1058 Execute (TOML frontmatter only works if it's the first thing in the file):
1059   let g:vim_markdown_toml_frontmatter=1
1060   syn off | syn on
1061   AssertNotEqual SyntaxOf('b'), 'tomlString'
1062   unlet g:vim_markdown_toml_frontmatter
1063
1064 # JSON frontmatter
1065
1066 Given markdown;
1067 {
1068   "a": "b"
1069 }
1070
1071 Execute (JSON frontmatter is controlled by the option):
1072   syn off | syn on
1073   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
1074   let g:vim_markdown_json_frontmatter=1
1075   syn off | syn on
1076   AssertEqual SyntaxOf('a'), 'jsonKeyword'
1077   let g:vim_markdown_json_frontmatter=0
1078   syn off | syn on
1079   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
1080
1081 Given markdown;
1082
1083 {
1084   "a": "b"
1085 }
1086
1087 Execute (JSON frontmatter only works if it's the first thing in the file):
1088   let g:vim_markdown_json_frontmatter=1
1089   syn off | syn on
1090   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
1091   unlet g:vim_markdown_json_frontmatter
1092
1093 # Header
1094
1095 Given markdown;
1096 # #a
1097 ccc
1098
1099 ## #b
1100 ddd
1101
1102 Execute (header title starts with #):
1103   AssertEqual SyntaxOf('a'), 'htmlH1'
1104   AssertEqual SyntaxOf('b'), 'htmlH2'
1105
1106 Given markdown;
1107 # h1 space
1108
1109 #h1 nospace
1110
1111 #  h1 2 spaces
1112
1113 # h1 trailing hash #
1114
1115 ## h2 space
1116
1117 ##h2 nospace
1118
1119 ## h2 trailing hash ##
1120
1121 ### h3 space
1122
1123 ###h3 nospace
1124
1125 ### h3 trailing hash ###
1126
1127 #### h4
1128
1129 ##### h5
1130
1131 ###### h6
1132
1133 Execute (atx headers):
1134   AssertEqual SyntaxOf('# h1 space'), 'htmlH1'
1135   AssertEqual SyntaxOf('#h1 nospace'), 'htmlH1'
1136   AssertEqual SyntaxOf('#  h1 2 spaces'), 'htmlH1'
1137   AssertEqual SyntaxOf('# h1 trailing hash #'), 'htmlH1'
1138   AssertEqual SyntaxOf('## h2 space'), 'htmlH2'
1139   AssertEqual SyntaxOf('##h2 nospace'), 'htmlH2'
1140   AssertEqual SyntaxOf('## h2 trailing hash ##'), 'htmlH2'
1141   AssertEqual SyntaxOf('### h3 space'), 'htmlH3'
1142   AssertEqual SyntaxOf('###h3 nospace'), 'htmlH3'
1143   AssertEqual SyntaxOf('### h3 trailing hash ###'), 'htmlH3'
1144   AssertEqual SyntaxOf('#### h4'), 'htmlH4'
1145   AssertEqual SyntaxOf('##### h5'), 'htmlH5'
1146   AssertEqual SyntaxOf('###### h6'), 'htmlH6'
1147
1148 Given markdown;
1149 # h1 before h2
1150
1151 ## h2 between h1s
1152
1153 # h1 after h2
1154
1155 Execute (atx headers relative positions):
1156   AssertEqual SyntaxOf('# h1 before h2'), 'htmlH1'
1157   AssertEqual SyntaxOf('## h2 between h1s'), 'htmlH2'
1158   AssertEqual SyntaxOf('# h1 after h2'), 'htmlH1'
1159
1160 Given markdown;
1161 setex h1
1162 ========
1163
1164 setex h2
1165 --------
1166
1167 setex h1 single punctuation
1168 =
1169
1170 setex h1 punctuation longer than header
1171 ================================
1172
1173 Execute (setex headers):
1174   AssertEqual SyntaxOf('setex h1'), 'htmlH1'
1175   AssertEqual SyntaxOf('^========$'), 'htmlH1'
1176   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
1177   AssertEqual SyntaxOf('--------'), 'htmlH2'
1178   AssertEqual SyntaxOf('setex h1 single punctuation'), 'htmlH1'
1179   AssertEqual SyntaxOf('^=$'), 'htmlH1'
1180   AssertEqual SyntaxOf('setex h1 punctuation longer than header'), 'htmlH1'
1181   AssertEqual SyntaxOf('^================================$'), 'htmlH1'
1182
1183 Given markdown;
1184 - not Setex
1185 - because list
1186
1187 Execute (prevent list vs Setex confusion):
1188   AssertNotEqual SyntaxOf('- not Setex'), 'htmlH2'
1189   AssertNotEqual SyntaxOf('- becuase list'), 'htmlH2'
1190
1191 Given markdown;
1192 setex h1 before atx
1193 ===================
1194
1195 ## atx h2
1196
1197 ### atx h3
1198
1199 # atx h1
1200
1201 setex h2
1202 ------------------
1203
1204 ### atx h3 2
1205
1206 Execute (mixed atx and setex headers):
1207   AssertEqual SyntaxOf('setex h1 before atx'), 'htmlH1'
1208   AssertEqual SyntaxOf('==================='), 'htmlH1'
1209   AssertEqual SyntaxOf('## atx h2'), 'htmlH2'
1210   AssertEqual SyntaxOf('### atx h3'), 'htmlH3'
1211   AssertEqual SyntaxOf('# atx h1'), 'htmlH1'
1212   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
1213   AssertEqual SyntaxOf('------------------'), 'htmlH2'
1214
1215 # List
1216
1217 Given markdown;
1218 - a & b
1219 1. c > d
1220
1221 Execute (& and > are not marked as htmlError in lists):
1222   AssertEqual SyntaxOf('-'), 'mkdListItem'
1223   AssertEqual SyntaxOf('1.'), 'mkdListItem'
1224   AssertNotEqual SyntaxOf('&'), 'htmlError'
1225   AssertNotEqual SyntaxOf('>'), 'htmlError'
1226
1227 Given markdown;
1228 1. a  
1229 2. b
1230
1231 Execute (list after line break):
1232   AssertEqual SyntaxOf('1'), 'mkdListItem'
1233   AssertEqual SyntaxOf('2'), 'mkdListItem'
1234
1235 # HTML
1236
1237 Given markdown;
1238 a
1239
1240 <p>b</p>
1241
1242 - <span>c</span>
1243
1244 Execute (HTML tag in text):
1245   AssertEqual SyntaxOf('p'), 'htmlTagName'
1246   AssertEqual SyntaxOf('<p>'), 'htmlTag'
1247   AssertEqual SyntaxOf('</p>'), 'htmlEndTag'
1248   AssertEqual SyntaxOf('span'), 'htmlTagName'
1249   AssertEqual SyntaxOf('<span>'), 'htmlTag'
1250   AssertEqual SyntaxOf('</span>'), 'htmlEndTag'