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

481b8a1f21473a42da4219ff6e234b4461e09a4e
[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 # Links
171
172 Given markdown;
173 [a](b)
174
175 Execute (link with title):
176   AssertEqual SyntaxOf('a'), 'mkdLink'
177   AssertEqual SyntaxOf('b'), 'mkdURL'
178
179 Given markdown;
180 [a
181 b](c)
182
183 Execute (link text with newline):
184   AssertEqual SyntaxOf('a'), 'mkdLink'
185   AssertEqual SyntaxOf('b'), 'mkdLink'
186   AssertEqual SyntaxOf('c'), 'mkdURL'
187
188 Given markdown;
189 (a)
190
191 (b)
192
193 Execute (parenthesis not in link):
194   AssertNotEqual SyntaxOf('a'), 'mkdURL'
195   AssertNotEqual SyntaxOf('b'), 'mkdURL'
196
197 Given markdown;
198 [a](b) c [d](e)
199
200 Execute (multiple links on a line):
201   AssertNotEqual SyntaxOf('c'), 'mkdLink'
202   AssertNotEqual SyntaxOf('c'), 'mkdURL'
203
204 Given markdown;
205 [a] (b)
206
207 Execute (space is not allowed between link text and parenthesis):
208   AssertNotEqual SyntaxOf('a'), 'mkdLink'
209   AssertNotEqual SyntaxOf('b'), 'mkdURL'
210
211 Given markdown;
212 [a](b)
213
214 Execute (conceal link):
215   if has('conceal')
216     setlocal conceallevel=2
217     AssertEqual synconcealed(1, 1)[0], 1
218     AssertEqual synconcealed(1, 2)[0], 0
219     AssertEqual synconcealed(1, 3)[0], 1
220     AssertEqual synconcealed(1, 4)[0], 1
221     AssertEqual synconcealed(1, 4)[0], 1
222     AssertEqual synconcealed(1, 5)[0], 1
223     AssertEqual synconcealed(1, 6)[0], 1
224     setlocal conceallevel=0
225   endif
226
227 Execute (disable conceal):
228   if has('conceal')
229     let g:vim_markdown_conceal=0
230     syn off | syn on
231     setlocal conceallevel=2
232     AssertEqual synconcealed(1, 1)[0], 0
233     AssertEqual synconcealed(1, 2)[0], 0
234     AssertEqual synconcealed(1, 3)[0], 0
235     AssertEqual synconcealed(1, 4)[0], 0
236     AssertEqual synconcealed(1, 4)[0], 0
237     AssertEqual synconcealed(1, 5)[0], 0
238     AssertEqual synconcealed(1, 6)[0], 0
239
240     let g:vim_markdown_conceal=1
241     syn off | syn on
242     AssertEqual synconcealed(1, 1)[0], 1
243     AssertEqual synconcealed(1, 2)[0], 0
244     AssertEqual synconcealed(1, 3)[0], 1
245     AssertEqual synconcealed(1, 4)[0], 1
246     AssertEqual synconcealed(1, 4)[0], 1
247     AssertEqual synconcealed(1, 5)[0], 1
248     AssertEqual synconcealed(1, 6)[0], 1
249
250     setlocal conceallevel=0
251     unlet g:vim_markdown_conceal
252     syn off | syn on
253   endif
254
255 # Autolinks
256
257 Given markdown;
258 a <http://b> c
259
260 Execute (autolink):
261   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
262   AssertEqual SyntaxOf('<'), 'mkdDelimiter'
263   AssertEqual SyntaxOf('b'), 'mkdInlineURL'
264   AssertEqual SyntaxOf('>'), 'mkdDelimiter'
265   AssertNotEqual SyntaxOf('c'), 'mkdInlineURL'
266
267 Given markdown;
268 http://12monkeys.foo
269
270 Execute (autolink with domain starting with a number):
271   AssertEqual SyntaxOf('12monkeys'), 'mkdInlineURL'
272
273 Given markdown;
274 <HtTp://a>
275
276 Execute (autolink with scheme case is insensitive):
277   AssertEqual SyntaxOf('a'), 'mkdInlineURL'
278
279 Given markdown;
280 <a>
281
282 Execute (autolink without scheme is not a link):
283   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
284
285 Given markdown;
286 < http://a >
287 <http://b c>
288 <http://d
289 e>
290
291 Execute (autolink with space is not a link):
292   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
293   AssertNotEqual SyntaxOf('b'), 'mkdInlineURL'
294   AssertNotEqual SyntaxOf('c'), 'mkdInlineURL'
295   AssertNotEqual SyntaxOf('d'), 'mkdInlineURL'
296   AssertNotEqual SyntaxOf('e'), 'mkdInlineURL'
297
298 Given markdown;
299 \<http://a>
300
301 Execute (autolinks can be backslash escaped):
302   AssertNotEqual SyntaxOf('<'), 'mkdDelimiter'
303
304 Given markdown;
305 a (http://b.bb) c
306
307 Execute (autolink in parenthesis):
308   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
309   AssertEqual SyntaxOf('('), 'mkdDelimiter'
310   AssertEqual SyntaxOf('b'), 'mkdInlineURL'
311   AssertEqual SyntaxOf(')'), 'mkdDelimiter'
312   AssertNotEqual SyntaxOf('c'), 'mkdInlineURL'
313
314 Given markdown;
315 [![a](http://b)](http://c)
316
317 Execute (autolink in link text):
318   AssertEqual SyntaxOf('!'), 'mkdDelimiter'
319   AssertEqual SyntaxOf('a'), 'mkdLink'
320   AssertEqual SyntaxOf('b'), 'mkdURL'
321   AssertEqual SyntaxOf('c'), 'mkdURL'
322
323 # Code Blocks
324
325 Given markdown;
326 ~~~
327 code
328 ~~~
329
330 Execute (code blocks can be fenced with tildes):
331   AssertEqual SyntaxOf('c'), 'mkdCode'
332
333 Given markdown;
334 ~~~~
335 code
336 ~~~~~
337
338 Execute (code blocks can be fenced with tildes longer than 3):
339   AssertEqual SyntaxOf('c'), 'mkdCode'
340
341 Given markdown;
342 ````
343 code
344 `````
345
346 Execute (code blocks can be fenced with backticks longer than 3):
347   AssertEqual SyntaxOf('c'), 'mkdCode'
348
349 Given markdown;
350 ~~~ruby
351 code
352 ~~~
353
354 Execute (code blocks can have a language specifier):
355   AssertEqual SyntaxOf('c'), 'mkdCode'
356
357 Given markdown;
358 ```c++
359 code
360 ```
361
362 text
363
364 Execute (code blocks can be fenced with backticks and a language specifier):
365   AssertEqual SyntaxOf('code'), 'mkdCode'
366   AssertNotEqual SyntaxOf('text'), 'mkdCode'
367
368 # Indent Code Blocks
369
370 Given markdown;
371 a
372
373     b
374     c
375
376 Execute (indent code blocks):
377   AssertNotEqual SyntaxOf('a'), 'mkdCode'
378   AssertEqual SyntaxOf('b'), 'mkdCode'
379   AssertEqual SyntaxOf('c'), 'mkdCode'
380
381 Given markdown;
382 # a
383
384 b
385
386     c
387
388 Execute (indent code blocks after header):
389   AssertNotEqual SyntaxOf('a'), 'mkdCode'
390   AssertNotEqual SyntaxOf('b'), 'mkdCode'
391   AssertEqual SyntaxOf('c'), 'mkdCode'
392
393 Given markdown;
394 -   a
395
396     b
397
398         c
399
400 Execute (indent code blocks after list):
401   AssertNotEqual SyntaxOf('a'), 'mkdCode'
402   AssertNotEqual SyntaxOf('b'), 'mkdCode'
403   AssertEqual SyntaxOf('c'), 'mkdCode'
404
405 Given markdown;
406     a
407     b
408
409 Execute (indent code block at beginning of file):
410   AssertEqual SyntaxOf('a'), 'mkdCode'
411   AssertEqual SyntaxOf('b'), 'mkdCode'
412
413 Given markdown;
414 ```c++
415 #include <iostream>
416 code
417 ```
418
419 ```ruby
420 def a
421 end
422 ```
423
424 Execute (fenced code block syntax with a language specifier):
425   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
426   call b:func(0)
427   AssertEqual SyntaxOf('include'), 'cInclude'
428   AssertEqual SyntaxOf('code'), 'mkdSnippetCPP'
429   AssertEqual SyntaxOf('def'), 'rubyDefine'
430
431 Given markdown;
432 ``` c++
433 #include <iostream>
434 code
435 ```
436
437 ```  vim
438 let g:a = 1
439 ```
440
441 ```     ruby
442 def a
443 end
444 ```
445
446 ```
447 ruby
448 class B
449 end
450 ```
451
452 Execute (fenced code block syntax with a language specifier after whitespace):
453   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
454   call b:func(0)
455   AssertEqual SyntaxOf('include'), 'cInclude'
456   AssertEqual SyntaxOf('code'), 'mkdSnippetCPP'
457   AssertEqual SyntaxOf('g:a'), 'vimVar'
458   AssertEqual SyntaxOf('def'), 'rubyDefine'
459   AssertNotEqual SyntaxOf('class'), 'rubyClass'
460
461 Given markdown;
462 ```vim
463 let g:a = 1
464 ```
465
466 ```viml
467 let g:b = 1
468 ```
469
470 Execute (fenced code block syntax with alias language specifier):
471   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
472   call b:func(0)
473   AssertEqual SyntaxOf('g:a'), 'vimVar'
474   AssertEqual SyntaxOf('g:b'), 'vimVar'
475
476 Given markdown;
477 ```csharp
478 var s = "foo";
479 ```
480
481 Execute (fenced code block languages setting):
482   let g:vim_markdown_fenced_languages = ['csharp=cs']
483   source ../ftplugin/markdown.vim
484   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
485   call b:func(0)
486   AssertEqual SyntaxOf('foo'), 'csString'
487   unlet g:vim_markdown_fenced_languages
488
489 Given markdown;
490 ```vim
491 let g:a = 1
492 ```
493
494 Execute (fenced code block includes language syntax with reopening same buffer):
495   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
496   call b:func(0)
497   split
498   quit
499   edit
500   set filetype=markdown
501   execute "normal! i```vim\<cr>let g:a = 1\<cr>```"
502   call b:func(1)
503   AssertEqual SyntaxOf('g:a'), 'vimVar'
504
505 Given markdown;
506 ```a+b-
507 code
508 ```
509
510 Execute (fenced code block syntax with an unknown language specifier):
511   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
512   call b:func(0)
513   AssertEqual SyntaxOf('code'), 'mkdSnippetA_B_'
514
515 Given markdown;
516 ```
517 =
518 a
519 -
520 ```
521
522 Execute (first = or - in fenced code block is not setex headers):
523   AssertEqual SyntaxOf('='), 'mkdCode'
524   AssertEqual SyntaxOf('-'), 'mkdCode'
525
526 Given markdown;
527 ``` {style=""}
528 a
529 ```
530
531 Execute (fenced code block with extended info strings):
532   AssertEqual SyntaxOf('a'), 'mkdCode'
533
534 # Code Blocks in pre and code tag
535
536 Given markdown;
537 <pre>
538 a
539 </pre>
540
541 Execute (code block in pre tag):
542   AssertEqual SyntaxOf('a'), 'mkdCode'
543
544 Given markdown;
545 <code>
546 a
547 </code>
548
549 Execute (code block in code tag):
550   AssertEqual SyntaxOf('a'), 'mkdCode'
551
552 Given markdown;
553 \<pre\>
554 a
555 \</pre\>
556
557 Execute (not code block in escaped pre tag):
558   AssertNotEqual SyntaxOf('a'), 'mkdCode'
559
560 Given markdown;
561 \<code\>
562 a
563 \</code\>
564
565 Execute (not code block in escaped code tag):
566   AssertNotEqual SyntaxOf('a'), 'mkdCode'
567
568 # Math
569
570 Given markdown;
571 a $x$ b
572 c $$y$$ d
573 \$e\$
574 \$\$f\$\$
575
576 Execute (math):
577   AssertNotEqual SyntaxOf('x'), 'mkdMath'
578   AssertNotEqual SyntaxOf('y'), 'mkdMath'
579   let g:vim_markdown_math=1
580   syn off | syn on
581   AssertNotEqual SyntaxOf('a'), 'mkdMath'
582   AssertNotEqual SyntaxOf('b'), 'mkdMath'
583   AssertNotEqual SyntaxOf('c'), 'mkdMath'
584   AssertNotEqual SyntaxOf('d'), 'mkdMath'
585   AssertNotEqual SyntaxOf('e'), 'mkdMath'
586   AssertNotEqual SyntaxOf('f'), 'mkdMath'
587   AssertEqual SyntaxOf('x'), 'mkdMath'
588   AssertEqual SyntaxOf('y'), 'mkdMath'
589   let g:vim_markdown_math=0
590   syn off | syn on
591   AssertNotEqual SyntaxOf('x'), 'mkdMath'
592   AssertNotEqual SyntaxOf('y'), 'mkdMath'
593
594 Given markdown;
595 a
596
597 $
598 b
599 $
600
601 c
602
603 Execute (multiline math):
604   let g:vim_markdown_math=1
605   syn off | syn on
606   AssertNotEqual SyntaxOf('a'), 'mkdMath'
607   AssertEqual SyntaxOf('b'), 'mkdMath'
608   AssertNotEqual SyntaxOf('c'), 'mkdMath'
609
610 Given markdown;
611 $ \sqrt{a}{b} $
612 $$ \frac{a}{b} $$
613
614 Execute (math tex highlighting):
615   let g:vim_markdown_math=0
616   syn off | syn on
617   AssertNotEqual SyntaxOf('sqrt'), 'texStatement'
618   AssertNotEqual SyntaxOf('frac'), 'texStatement'
619   let g:vim_markdown_math=1
620   syn off | syn on
621   AssertEqual SyntaxOf('sqrt'), 'texStatement'
622   AssertEqual SyntaxOf('frac'), 'texStatement'
623
624 Given markdown;
625 $a b[$ c
626
627 Execute (math ends with $):
628   let g:vim_markdown_math=1
629   syn off | syn on
630   AssertEqual SyntaxOf('a'), 'mkdMath'
631   AssertEqual SyntaxOf('b'), 'mkdMath'
632   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
633
634 Given markdown;
635 $$a b[$$ c
636
637 Execute (math ends with $$):
638   let g:vim_markdown_math=1
639   syn off | syn on
640   AssertEqual SyntaxOf('a'), 'mkdMath'
641   AssertEqual SyntaxOf('b'), 'mkdMath'
642   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
643
644 # YAML frontmatter
645
646 Given markdown;
647 ---
648 a: b
649 ---
650
651 Execute (YAML frontmatter is controlled by the option):
652   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
653   let g:vim_markdown_frontmatter=1
654   syn off | syn on
655   AssertEqual SyntaxOf('a')[0:3], 'yaml'
656   let g:vim_markdown_frontmatter=0
657   syn off | syn on
658   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
659
660 Given markdown;
661
662 ---
663 a: b
664 ---
665
666 Execute (YAML frontmatter only works if it's the first thing in the file):
667   let g:vim_markdown_frontmatter=1
668   syn off | syn on
669   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
670
671 Given markdown;
672 ---
673 a: b
674 ---
675
676 ---
677
678 Execute (rules are not mistaken by YAML frontmatter delimiters):
679   let g:vim_markdown_frontmatter=1
680   syn off | syn on
681   AssertEqual SyntaxAt(5, 1), 'mkdRule'
682   unlet g:vim_markdown_frontmatter
683
684 # TOML frontmatter
685
686 Given markdown;
687 +++
688 a = "b"
689 +++
690
691 Execute (TOML frontmatter is controlled by the option):
692   syn off | syn on
693   AssertNotEqual SyntaxOf('b'), 'tomlString'
694   let g:vim_markdown_toml_frontmatter=1
695   syn off | syn on
696   AssertEqual SyntaxOf('b'), 'tomlString'
697   let g:vim_markdown_toml_frontmatter=0
698   syn off | syn on
699   AssertNotEqual SyntaxOf('b'), 'tomlString'
700
701 Given markdown;
702
703 +++
704 a = "b"
705 +++
706
707 Execute (TOML frontmatter only works if it's the first thing in the file):
708   let g:vim_markdown_toml_frontmatter=1
709   syn off | syn on
710   AssertNotEqual SyntaxOf('b'), 'tomlString'
711   unlet g:vim_markdown_toml_frontmatter
712
713 # JSON frontmatter
714
715 Given markdown;
716 {
717   "a": "b"
718 }
719
720 Execute (JSON frontmatter is controlled by the option):
721   syn off | syn on
722   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
723   let g:vim_markdown_json_frontmatter=1
724   syn off | syn on
725   AssertEqual SyntaxOf('a'), 'jsonKeyword'
726   let g:vim_markdown_json_frontmatter=0
727   syn off | syn on
728   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
729
730 Given markdown;
731
732 {
733   "a": "b"
734 }
735
736 Execute (JSON frontmatter only works if it's the first thing in the file):
737   let g:vim_markdown_json_frontmatter=1
738   syn off | syn on
739   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
740   unlet g:vim_markdown_json_frontmatter
741
742 # Header
743
744 Given markdown;
745 # #a
746 ccc
747
748 ## #b
749 ddd
750
751 Execute (header title starts with #):
752   AssertEqual SyntaxOf('a'), 'htmlH1'
753   AssertEqual SyntaxOf('b'), 'htmlH2'
754
755 Given markdown;
756 # h1 space
757
758 #h1 nospace
759
760 #  h1 2 spaces
761
762 # h1 trailing hash #
763
764 ## h2 space
765
766 ##h2 nospace
767
768 ## h2 trailing hash ##
769
770 ### h3 space
771
772 ###h3 nospace
773
774 ### h3 trailing hash ###
775
776 #### h4
777
778 ##### h5
779
780 ###### h6
781
782 Execute (atx headers):
783   AssertEqual SyntaxOf('# h1 space'), 'htmlH1'
784   AssertEqual SyntaxOf('#h1 nospace'), 'htmlH1'
785   AssertEqual SyntaxOf('#  h1 2 spaces'), 'htmlH1'
786   AssertEqual SyntaxOf('# h1 trailing hash #'), 'htmlH1'
787   AssertEqual SyntaxOf('## h2 space'), 'htmlH2'
788   AssertEqual SyntaxOf('##h2 nospace'), 'htmlH2'
789   AssertEqual SyntaxOf('## h2 trailing hash ##'), 'htmlH2'
790   AssertEqual SyntaxOf('### h3 space'), 'htmlH3'
791   AssertEqual SyntaxOf('###h3 nospace'), 'htmlH3'
792   AssertEqual SyntaxOf('### h3 trailing hash ###'), 'htmlH3'
793   AssertEqual SyntaxOf('#### h4'), 'htmlH4'
794   AssertEqual SyntaxOf('##### h5'), 'htmlH5'
795   AssertEqual SyntaxOf('###### h6'), 'htmlH6'
796
797 Given markdown;
798 # h1 before h2
799
800 ## h2 between h1s
801
802 # h1 after h2
803
804 Execute (atx headers relative positions):
805   AssertEqual SyntaxOf('# h1 before h2'), 'htmlH1'
806   AssertEqual SyntaxOf('## h2 between h1s'), 'htmlH2'
807   AssertEqual SyntaxOf('# h1 after h2'), 'htmlH1'
808
809 Given markdown;
810 setex h1
811 ========
812
813 setex h2
814 --------
815
816 setex h1 single punctuation
817 =
818
819 setex h1 punctuation longer than header
820 ================================
821
822 Execute (setex headers):
823   AssertEqual SyntaxOf('setex h1'), 'htmlH1'
824   AssertEqual SyntaxOf('^========$'), 'htmlH1'
825   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
826   AssertEqual SyntaxOf('--------'), 'htmlH2'
827   AssertEqual SyntaxOf('setex h1 single punctuation'), 'htmlH1'
828   AssertEqual SyntaxOf('^=$'), 'htmlH1'
829   AssertEqual SyntaxOf('setex h1 punctuation longer than header'), 'htmlH1'
830   AssertEqual SyntaxOf('^================================$'), 'htmlH1'
831
832 Given markdown;
833 - not Setex
834 - because list
835
836 Execute (prevent list vs Setex confusion):
837   AssertNotEqual SyntaxOf('- not Setex'), 'htmlH2'
838   AssertNotEqual SyntaxOf('- becuase list'), 'htmlH2'
839
840 Given markdown;
841 setex h1 before atx
842 ===================
843
844 ## atx h2
845
846 ### atx h3
847
848 # atx h1
849
850 setex h2
851 ------------------
852
853 ### atx h3 2
854
855 Execute (mixed atx and setex headers):
856   AssertEqual SyntaxOf('setex h1 before atx'), 'htmlH1'
857   AssertEqual SyntaxOf('==================='), 'htmlH1'
858   AssertEqual SyntaxOf('## atx h2'), 'htmlH2'
859   AssertEqual SyntaxOf('### atx h3'), 'htmlH3'
860   AssertEqual SyntaxOf('# atx h1'), 'htmlH1'
861   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
862   AssertEqual SyntaxOf('------------------'), 'htmlH2'
863
864 # List
865
866 Given markdown;
867 - a & b
868 1. c > d
869
870 Execute (& and > are not marked as htmlError in lists):
871   AssertEqual SyntaxOf('-'), 'mkdListItem'
872   AssertEqual SyntaxOf('1.'), 'mkdListItem'
873   AssertNotEqual SyntaxOf('&'), 'htmlError'
874   AssertNotEqual SyntaxOf('>'), 'htmlError'
875
876 Given markdown;
877 1. a  
878 2. b
879
880 Execute (list after line break):
881   AssertEqual SyntaxOf('1'), 'mkdListItem'
882   AssertEqual SyntaxOf('2'), 'mkdListItem'
883
884 # HTML
885
886 Given markdown;
887 a
888
889 <p>b</p>
890
891 - <span>c</span>
892
893 Execute (HTML tag in text):
894   AssertEqual SyntaxOf('p'), 'htmlTagName'
895   AssertEqual SyntaxOf('<p>'), 'htmlTag'
896   AssertEqual SyntaxOf('</p>'), 'htmlEndTag'
897   AssertEqual SyntaxOf('span'), 'htmlTagName'
898   AssertEqual SyntaxOf('<span>'), 'htmlTag'
899   AssertEqual SyntaxOf('</span>'), 'htmlEndTag'