]> git.madduck.net Git - etc/vim.git/blob - .vim/bundle/vim-markdown/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:

Merge commit '907d4569b0384e76f9e3ca4a6a7ee917712c031d' into tmp
[etc/vim.git] / .vim / bundle / vim-markdown / 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 Given markdown;
633 [https://domain.tld](https://domain.com) not_a_link
634
635 Execute (link with url title):
636   AssertEqual SyntaxOf('https://domain.tld'), 'mkdInlineURL'
637   AssertEqual SyntaxOf('https://domain.com'), 'mkdInlineURL'
638   AssertNotEqual SyntaxOf('not_a_link'), 'mkdInlineURL'
639
640 # Code Blocks
641
642 Given markdown;
643 ~~~
644 code
645 ~~~
646
647 Execute (code blocks can be fenced with tildes):
648   AssertEqual SyntaxOf('c'), 'mkdCode'
649
650 Given markdown;
651 ~~~~
652 code
653 ~~~~~
654
655 Execute (code blocks can be fenced with tildes longer than 3):
656   AssertEqual SyntaxOf('c'), 'mkdCode'
657
658 Given markdown;
659 ````
660 code
661 `````
662
663 Execute (code blocks can be fenced with backticks longer than 3):
664   AssertEqual SyntaxOf('c'), 'mkdCode'
665
666 Given markdown;
667 ~~~ruby
668 code
669 ~~~
670
671 Execute (code blocks can have a language specifier):
672   AssertEqual SyntaxOf('c'), 'mkdCode'
673
674 Given markdown;
675 ```c++
676 code
677 ```
678
679 text
680
681 Execute (code blocks can be fenced with backticks and a language specifier):
682   AssertEqual SyntaxOf('code'), 'mkdCode'
683   AssertNotEqual SyntaxOf('text'), 'mkdCode'
684
685 # Indent Code Blocks
686
687 Given markdown;
688 a
689
690     b
691     c
692
693 Execute (indent code blocks):
694   AssertNotEqual SyntaxOf('a'), 'mkdCode'
695   AssertEqual SyntaxOf('b'), 'mkdCode'
696   AssertEqual SyntaxOf('c'), 'mkdCode'
697
698 Given markdown;
699 # a
700
701 b
702
703     c
704
705 Execute (indent code blocks after header):
706   AssertNotEqual SyntaxOf('a'), 'mkdCode'
707   AssertNotEqual SyntaxOf('b'), 'mkdCode'
708   AssertEqual SyntaxOf('c'), 'mkdCode'
709
710 Given markdown;
711 -   a
712
713     b
714
715         c
716
717 Execute (indent code blocks after list):
718   AssertNotEqual SyntaxOf('a'), 'mkdCode'
719   AssertNotEqual SyntaxOf('b'), 'mkdCode'
720   AssertEqual SyntaxOf('c'), 'mkdCode'
721
722 Given markdown;
723     a
724     b
725
726 Execute (indent code block at beginning of file):
727   AssertEqual SyntaxOf('a'), 'mkdCode'
728   AssertEqual SyntaxOf('b'), 'mkdCode'
729
730 Given markdown;
731 ```c++
732 #include <iostream>
733 code
734 ```
735
736 ```ruby
737 def a
738 end
739 ```
740
741 Execute (fenced code block syntax with a language specifier):
742   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
743   call b:func(0)
744   AssertEqual SyntaxOf('include'), 'cInclude'
745   AssertEqual SyntaxOf('code'), 'mkdSnippetCPP'
746   AssertEqual SyntaxOf('def'), 'rubyDefine'
747
748 Given markdown;
749 ``` c++
750 #include <iostream>
751 code
752 ```
753
754 ```  vim
755 let g:a = 1
756 ```
757
758 ```     ruby
759 def a
760 end
761 ```
762
763 ```
764 ruby
765 class B
766 end
767 ```
768
769 Execute (fenced code block syntax with a language specifier after whitespace):
770   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
771   call b:func(0)
772   AssertEqual SyntaxOf('include'), 'cInclude'
773   AssertEqual SyntaxOf('code'), 'mkdSnippetCPP'
774   AssertEqual SyntaxOf('g:a'), 'vimVar'
775   AssertEqual SyntaxOf('def'), 'rubyDefine'
776   AssertNotEqual SyntaxOf('class'), 'rubyClass'
777
778 Given markdown;
779 ```vim
780 let g:a = 1
781 ```
782
783 ```viml
784 let g:b = 1
785 ```
786
787 Execute (fenced code block syntax with alias language specifier):
788   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
789   call b:func(0)
790   AssertEqual SyntaxOf('g:a'), 'vimVar'
791   AssertEqual SyntaxOf('g:b'), 'vimVar'
792
793 Given markdown;
794 ```csharp
795 var s = "foo";
796 ```
797
798 Execute (fenced code block languages setting):
799   let g:vim_markdown_fenced_languages = ['csharp=cs']
800   source ../ftplugin/markdown.vim
801   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
802   call b:func(0)
803   AssertEqual SyntaxOf('foo'), 'csString'
804   unlet g:vim_markdown_fenced_languages
805
806 Given markdown;
807 ```vim
808 let g:a = 1
809 ```
810
811 Execute (fenced code block includes language syntax with reopening same buffer):
812   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
813   call b:func(0)
814   split
815   quit
816   edit
817   set filetype=markdown
818   execute "normal! i```vim\<cr>let g:a = 1\<cr>```"
819   call b:func(1)
820   AssertEqual SyntaxOf('g:a'), 'vimVar'
821
822 Given markdown;
823 ```a+b-
824 code
825 ```
826
827 Execute (fenced code block syntax with an unknown language specifier):
828   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
829   call b:func(0)
830   AssertEqual SyntaxOf('code'), 'mkdSnippetA_B_'
831
832 Given markdown;
833 ```
834 =
835 a
836 -
837 ```
838
839 Execute (first = or - in fenced code block is not setex headers):
840   AssertEqual SyntaxOf('='), 'mkdCode'
841   AssertEqual SyntaxOf('-'), 'mkdCode'
842
843 Given markdown;
844 ``` {style=""}
845 a
846 ```
847
848 Execute (fenced code block with extended info strings):
849   AssertEqual SyntaxOf('a'), 'mkdCode'
850
851 # Code Blocks in pre and code tag
852
853 Given markdown;
854 <pre>
855 a
856 </pre>
857
858 Execute (code block in pre tag):
859   AssertEqual SyntaxOf('a'), 'mkdCode'
860
861 Given markdown;
862 <code>
863 a
864 </code>
865
866 Execute (code block in code tag):
867   AssertEqual SyntaxOf('a'), 'mkdCode'
868
869 Given markdown;
870 \<pre\>
871 a
872 \</pre\>
873
874 Execute (not code block in escaped pre tag):
875   AssertNotEqual SyntaxOf('a'), 'mkdCode'
876
877 Given markdown;
878 \<code\>
879 a
880 \</code\>
881
882 Execute (not code block in escaped code tag):
883   AssertNotEqual SyntaxOf('a'), 'mkdCode'
884
885 # Code quotes
886
887 Given markdown;
888 `a`
889
890 Execute (code in code quotes):
891   AssertEqual SyntaxOf('a'), 'mkdCode'
892
893 Given markdown;
894 `a\` b `c\` d
895
896 Execute (code quotes not escaped ending with backslash):
897   AssertEqual SyntaxOf('a\'), 'mkdCode'
898   AssertNotEqual SyntaxOf('b'), 'mkdCode'
899   AssertEqual SyntaxOf('c\'), 'mkdCode'
900   AssertNotEqual SyntaxOf('d'), 'mkdCode'
901
902 Given markdown;
903 ``a\`` b ``c`\`1`` d
904
905 Execute (double code quotes not escaped ending with backslash):
906   AssertEqual SyntaxOf('a\'), 'mkdCode'
907   AssertNotEqual SyntaxOf('b'), 'mkdCode'
908   AssertEqual SyntaxOf('c`\\`1'), 'mkdCode'
909   AssertNotEqual SyntaxOf('d'), 'mkdCode'
910
911 # Math
912
913 Given markdown;
914 a $x$ b
915 c $$y$$ d
916 \$e\$
917 \$\$f\$\$
918
919 Execute (math):
920   AssertNotEqual SyntaxOf('x')[0:2], 'tex'
921   AssertNotEqual SyntaxOf('y')[0:2], 'tex'
922   let g:vim_markdown_math=1
923   syn off | syn on
924   AssertNotEqual SyntaxOf('a')[0:2], 'tex'
925   AssertNotEqual SyntaxOf('b')[0:2], 'tex'
926   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
927   AssertNotEqual SyntaxOf('d')[0:2], 'tex'
928   AssertNotEqual SyntaxOf('e')[0:2], 'tex'
929   AssertNotEqual SyntaxOf('f')[0:2], 'tex'
930   AssertEqual SyntaxOf('x')[0:2], 'tex'
931   AssertEqual SyntaxOf('y')[0:2], 'tex'
932   let g:vim_markdown_math=0
933   syn off | syn on
934   AssertNotEqual SyntaxOf('x')[0:2], 'tex'
935   AssertNotEqual SyntaxOf('y')[0:2], 'tex'
936
937 Given markdown;
938 a
939
940 $
941 b
942 $
943
944 c
945
946 Execute (multiline math):
947   let g:vim_markdown_math=1
948   syn off | syn on
949   AssertNotEqual SyntaxOf('a')[0:2], 'tex'
950   AssertEqual SyntaxOf('b')[0:2], 'tex'
951   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
952
953 Given markdown;
954 $ \sqrt{a}{b} $
955 $$ \frac{a}{b} $$
956
957 Execute (math tex highlighting):
958   let g:vim_markdown_math=0
959   syn off | syn on
960   AssertNotEqual SyntaxOf('sqrt'), 'texStatement'
961   AssertNotEqual SyntaxOf('frac'), 'texStatement'
962   let g:vim_markdown_math=1
963   syn off | syn on
964   AssertEqual SyntaxOf('sqrt'), 'texStatement'
965   AssertEqual SyntaxOf('frac'), 'texStatement'
966
967 Given markdown;
968 $a b[$ c
969
970 Execute (math ends with $):
971   let g:vim_markdown_math=1
972   syn off | syn on
973   AssertEqual SyntaxOf('a')[0:2], 'tex'
974   AssertEqual SyntaxOf('b')[0:2], 'tex'
975   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
976
977 Given markdown;
978 $$a b[$$ c
979
980 Execute (math ends with $$):
981   let g:vim_markdown_math=1
982   syn off | syn on
983   AssertEqual SyntaxOf('a')[0:2], 'tex'
984   AssertEqual SyntaxOf('b')[0:2], 'tex'
985   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
986
987 Given markdown;
988 $(0 \le 1)$
989
990 Execute (math conceal in $):
991   if has('conceal')
992     setlocal conceallevel=2
993     let g:vim_markdown_math=1
994     syn off | syn on
995     AssertEqual synconcealed(1, 1)[0], 1, '$'
996     AssertEqual synconcealed(1, 2)[0], 0
997     AssertEqual synconcealed(1, 3)[0], 0
998     AssertEqual synconcealed(1, 4)[0], 0
999     AssertEqual synconcealed(1, 5)[0], 1, '\le'
1000     AssertEqual synconcealed(1, 6)[0], 1
1001     AssertEqual synconcealed(1, 7)[0], 1
1002     AssertEqual synconcealed(1, 8)[0], 0
1003     AssertEqual synconcealed(1, 9)[0], 0
1004     AssertEqual synconcealed(1, 10)[0], 0
1005     AssertEqual synconcealed(1, 11)[0], 1, '$'
1006     setlocal conceallevel=0
1007   endif
1008
1009 Given markdown;
1010 $$
1011 \omega
1012 0 \le 1
1013 $$
1014
1015 Execute (math conceal in $$):
1016   if has('conceal')
1017     setlocal conceallevel=2
1018     let g:vim_markdown_math=1
1019     syn off | syn on
1020     AssertEqual synconcealed(1, 1)[0], 1, '$$'
1021     AssertEqual synconcealed(2, 1)[0], 1, '\omega'
1022     AssertEqual synconcealed(3, 1)[0], 0, '0'
1023     AssertEqual synconcealed(3, 3)[0], 1, '\le'
1024     AssertEqual synconcealed(3, 7)[0], 0, '1'
1025     AssertEqual synconcealed(4, 1)[0], 1, '$$'
1026     setlocal conceallevel=0
1027   endif
1028
1029 # YAML frontmatter
1030
1031 Given markdown;
1032 ---
1033 a: b
1034 ---
1035
1036 Execute (YAML frontmatter is controlled by the option):
1037   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
1038   let g:vim_markdown_frontmatter=1
1039   syn off | syn on
1040   AssertEqual SyntaxOf('a')[0:3], 'yaml'
1041   let g:vim_markdown_frontmatter=0
1042   syn off | syn on
1043   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
1044
1045 Given markdown;
1046
1047 ---
1048 a: b
1049 ---
1050
1051 Execute (YAML frontmatter only works if it's the first thing in the file):
1052   let g:vim_markdown_frontmatter=1
1053   syn off | syn on
1054   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
1055
1056 Given markdown;
1057 ---
1058 a: b
1059 ---
1060
1061 ---
1062
1063 Execute (rules are not mistaken by YAML frontmatter delimiters):
1064   let g:vim_markdown_frontmatter=1
1065   syn off | syn on
1066   AssertEqual SyntaxAt(5, 1), 'mkdRule'
1067   unlet g:vim_markdown_frontmatter
1068
1069 # TOML frontmatter
1070
1071 Given markdown;
1072 +++
1073 a = "b"
1074 +++
1075
1076 Execute (TOML frontmatter is controlled by the option):
1077   syn off | syn on
1078   AssertNotEqual SyntaxOf('b'), 'tomlString'
1079   let g:vim_markdown_toml_frontmatter=1
1080   syn off | syn on
1081   AssertEqual SyntaxOf('b'), 'tomlString'
1082   let g:vim_markdown_toml_frontmatter=0
1083   syn off | syn on
1084   AssertNotEqual SyntaxOf('b'), 'tomlString'
1085
1086 Given markdown;
1087
1088 +++
1089 a = "b"
1090 +++
1091
1092 Execute (TOML frontmatter only works if it's the first thing in the file):
1093   let g:vim_markdown_toml_frontmatter=1
1094   syn off | syn on
1095   AssertNotEqual SyntaxOf('b'), 'tomlString'
1096   unlet g:vim_markdown_toml_frontmatter
1097
1098 # JSON frontmatter
1099
1100 Given markdown;
1101 {
1102   "a": "b"
1103 }
1104
1105 Execute (JSON frontmatter is controlled by the option):
1106   syn off | syn on
1107   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
1108   let g:vim_markdown_json_frontmatter=1
1109   syn off | syn on
1110   AssertEqual SyntaxOf('a'), 'jsonKeyword'
1111   let g:vim_markdown_json_frontmatter=0
1112   syn off | syn on
1113   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
1114
1115 Given markdown;
1116
1117 {
1118   "a": "b"
1119 }
1120
1121 Execute (JSON frontmatter only works if it's the first thing in the file):
1122   let g:vim_markdown_json_frontmatter=1
1123   syn off | syn on
1124   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
1125   unlet g:vim_markdown_json_frontmatter
1126
1127 # Header
1128
1129 Given markdown;
1130 # #a
1131 ccc
1132
1133 ## #b
1134 ddd
1135
1136 Execute (header title starts with #):
1137   AssertEqual SyntaxOf('a'), 'htmlH1'
1138   AssertEqual SyntaxOf('b'), 'htmlH2'
1139
1140 Given markdown;
1141 # h1 space
1142
1143 #h1 nospace
1144
1145 #  h1 2 spaces
1146
1147 # h1 trailing hash #
1148
1149 ## h2 space
1150
1151 ##h2 nospace
1152
1153 ## h2 trailing hash ##
1154
1155 ### h3 space
1156
1157 ###h3 nospace
1158
1159 ### h3 trailing hash ###
1160
1161 #### h4
1162
1163 ##### h5
1164
1165 ###### h6
1166
1167 Execute (atx headers):
1168   AssertEqual SyntaxOf(' h1 space'), 'htmlH1'
1169   AssertEqual SyntaxOf('h1 nospace'), 'htmlH1'
1170   AssertEqual SyntaxOf('  h1 2 spaces'), 'htmlH1'
1171   AssertEqual SyntaxOf(' h1 trailing hash '), 'htmlH1'
1172   AssertEqual SyntaxOf(' h2 space'), 'htmlH2'
1173   AssertEqual SyntaxOf('h2 nospace'), 'htmlH2'
1174   AssertEqual SyntaxOf(' h2 trailing hash '), 'htmlH2'
1175   AssertEqual SyntaxOf(' h3 space'), 'htmlH3'
1176   AssertEqual SyntaxOf('h3 nospace'), 'htmlH3'
1177   AssertEqual SyntaxOf(' h3 trailing hash '), 'htmlH3'
1178   AssertEqual SyntaxOf(' h4'), 'htmlH4'
1179   AssertEqual SyntaxOf(' h5'), 'htmlH5'
1180   AssertEqual SyntaxOf(' h6'), 'htmlH6'
1181
1182 Given markdown;
1183 # h1 before h2
1184
1185 ## h2 between h1s
1186
1187 # h1 after h2
1188
1189 Execute (atx headers relative positions):
1190   AssertEqual SyntaxOf(' h1 before h2'), 'htmlH1'
1191   AssertEqual SyntaxOf(' h2 between h1s'), 'htmlH2'
1192   AssertEqual SyntaxOf(' h1 after h2'), 'htmlH1'
1193
1194 Given markdown;
1195 setex h1
1196 ========
1197
1198 setex h2
1199 --------
1200
1201 setex h1 single punctuation
1202 =
1203
1204 setex h1 punctuation longer than header
1205 ================================
1206
1207 Execute (setex headers):
1208   AssertEqual SyntaxOf('setex h1'), 'htmlH1'
1209   AssertEqual SyntaxOf('^========$'), 'htmlH1'
1210   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
1211   AssertEqual SyntaxOf('--------'), 'htmlH2'
1212   AssertEqual SyntaxOf('setex h1 single punctuation'), 'htmlH1'
1213   AssertEqual SyntaxOf('^=$'), 'htmlH1'
1214   AssertEqual SyntaxOf('setex h1 punctuation longer than header'), 'htmlH1'
1215   AssertEqual SyntaxOf('^================================$'), 'htmlH1'
1216
1217 Given markdown;
1218 - not Setex
1219 - because list
1220
1221 Execute (prevent list vs Setex confusion):
1222   AssertNotEqual SyntaxOf('- not Setex'), 'htmlH2'
1223   AssertNotEqual SyntaxOf('- becuase list'), 'htmlH2'
1224
1225 Given markdown;
1226 setex h1 before atx
1227 ===================
1228
1229 ## atx h2
1230
1231 ### atx h3
1232
1233 # atx h1
1234
1235 setex h2
1236 ------------------
1237
1238 ### atx h3 2
1239
1240 Execute (mixed atx and setex headers):
1241   AssertEqual SyntaxOf('setex h1 before atx'), 'htmlH1'
1242   AssertEqual SyntaxOf('==================='), 'htmlH1'
1243   AssertEqual SyntaxOf(' atx h2'), 'htmlH2'
1244   AssertEqual SyntaxOf(' atx h3'), 'htmlH3'
1245   AssertEqual SyntaxOf(' atx h1'), 'htmlH1'
1246   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
1247   AssertEqual SyntaxOf('------------------'), 'htmlH2'
1248
1249 # List
1250
1251 Given markdown;
1252 - a & b
1253 1. c > d
1254
1255 Execute (& and > are not marked as htmlError in lists):
1256   AssertEqual SyntaxOf('-'), 'mkdListItem'
1257   AssertEqual SyntaxOf('1.'), 'mkdListItem'
1258   AssertNotEqual SyntaxOf('&'), 'htmlError'
1259   AssertNotEqual SyntaxOf('>'), 'htmlError'
1260
1261 Given markdown;
1262 1. a  
1263 2. b
1264
1265 Execute (list after line break):
1266   AssertEqual SyntaxOf('1'), 'mkdListItem'
1267   AssertEqual SyntaxOf('2'), 'mkdListItem'
1268
1269 # HTML
1270
1271 Given markdown;
1272 a
1273
1274 <p>b</p>
1275
1276 - <span>c</span>
1277
1278 Execute (HTML tag in text):
1279   AssertEqual SyntaxOf('p'), 'htmlTagName'
1280   AssertEqual SyntaxOf('<p>'), 'htmlTag'
1281   AssertEqual SyntaxOf('</p>'), 'htmlEndTag'
1282   AssertEqual SyntaxOf('span'), 'htmlTagName'
1283   AssertEqual SyntaxOf('<span>'), 'htmlTag'
1284   AssertEqual SyntaxOf('</span>'), 'htmlEndTag'