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

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