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

madduck's git repository

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

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

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

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

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

Add -H option for permission errors on travis
[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 Given markdown;
324 # [h1link](url)
325
326 ## [h2link](url)
327
328 ### [h3link](url)
329
330 #### [h4link](url)
331
332 ##### [h5link](url)
333
334 ###### [h6link](url)
335
336 [h1link_b](url)
337 ===============
338
339 [h2link_b](url)
340 ---------------
341
342 Execute (link in headers):
343   AssertEqual SyntaxOf('h1link'), 'mkdLink'
344   AssertEqual SyntaxOf('h2link'), 'mkdLink'
345   AssertEqual SyntaxOf('h3link'), 'mkdLink'
346   AssertEqual SyntaxOf('h4link'), 'mkdLink'
347   AssertEqual SyntaxOf('h5link'), 'mkdLink'
348   AssertEqual SyntaxOf('h6link'), 'mkdLink'
349   AssertEqual SyntaxOf('h1link_b'), 'mkdLink'
350   AssertEqual SyntaxOf('h2link_b'), 'mkdLink'
351
352 Given markdown;
353 # http://h1link.foo
354
355 ## http://h2link.foo
356
357 ### http://h3link.foo
358
359 #### http://h4link.foo
360
361 ##### http://h5link.foo
362
363 ###### http://h6link.foo
364
365 http://h1link_b.foo
366 ===================
367
368 http://h2link_b.foo
369 -------------------
370
371 Execute (inline url in headers):
372   AssertEqual SyntaxOf('h1link'), 'mkdInlineURL'
373   AssertEqual SyntaxOf('h2link'), 'mkdInlineURL'
374   AssertEqual SyntaxOf('h3link'), 'mkdInlineURL'
375   AssertEqual SyntaxOf('h4link'), 'mkdInlineURL'
376   AssertEqual SyntaxOf('h5link'), 'mkdInlineURL'
377   AssertEqual SyntaxOf('h6link'), 'mkdInlineURL'
378   AssertEqual SyntaxOf('h1link_b'), 'mkdInlineURL'
379   AssertEqual SyntaxOf('h2link_b'), 'mkdInlineURL'
380
381 Given markdown;
382 > [a](b)
383 > http://foo.bar
384
385 Execute (link in blockquote):
386   AssertEqual SyntaxOf('a'), 'mkdLink'
387   AssertEqual SyntaxOf('foo'), 'mkdInlineURL'
388
389 # Code Blocks
390
391 Given markdown;
392 ~~~
393 code
394 ~~~
395
396 Execute (code blocks can be fenced with tildes):
397   AssertEqual SyntaxOf('c'), 'mkdCode'
398
399 Given markdown;
400 ~~~~
401 code
402 ~~~~~
403
404 Execute (code blocks can be fenced with tildes longer than 3):
405   AssertEqual SyntaxOf('c'), 'mkdCode'
406
407 Given markdown;
408 ````
409 code
410 `````
411
412 Execute (code blocks can be fenced with backticks longer than 3):
413   AssertEqual SyntaxOf('c'), 'mkdCode'
414
415 Given markdown;
416 ~~~ruby
417 code
418 ~~~
419
420 Execute (code blocks can have a language specifier):
421   AssertEqual SyntaxOf('c'), 'mkdCode'
422
423 Given markdown;
424 ```c++
425 code
426 ```
427
428 text
429
430 Execute (code blocks can be fenced with backticks and a language specifier):
431   AssertEqual SyntaxOf('code'), 'mkdCode'
432   AssertNotEqual SyntaxOf('text'), 'mkdCode'
433
434 # Indent Code Blocks
435
436 Given markdown;
437 a
438
439     b
440     c
441
442 Execute (indent code blocks):
443   AssertNotEqual SyntaxOf('a'), 'mkdCode'
444   AssertEqual SyntaxOf('b'), 'mkdCode'
445   AssertEqual SyntaxOf('c'), 'mkdCode'
446
447 Given markdown;
448 # a
449
450 b
451
452     c
453
454 Execute (indent code blocks after header):
455   AssertNotEqual SyntaxOf('a'), 'mkdCode'
456   AssertNotEqual SyntaxOf('b'), 'mkdCode'
457   AssertEqual SyntaxOf('c'), 'mkdCode'
458
459 Given markdown;
460 -   a
461
462     b
463
464         c
465
466 Execute (indent code blocks after list):
467   AssertNotEqual SyntaxOf('a'), 'mkdCode'
468   AssertNotEqual SyntaxOf('b'), 'mkdCode'
469   AssertEqual SyntaxOf('c'), 'mkdCode'
470
471 Given markdown;
472     a
473     b
474
475 Execute (indent code block at beginning of file):
476   AssertEqual SyntaxOf('a'), 'mkdCode'
477   AssertEqual SyntaxOf('b'), 'mkdCode'
478
479 Given markdown;
480 ```c++
481 #include <iostream>
482 code
483 ```
484
485 ```ruby
486 def a
487 end
488 ```
489
490 Execute (fenced code block syntax with a language specifier):
491   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
492   call b:func(0)
493   AssertEqual SyntaxOf('include'), 'cInclude'
494   AssertEqual SyntaxOf('code'), 'mkdSnippetCPP'
495   AssertEqual SyntaxOf('def'), 'rubyDefine'
496
497 Given markdown;
498 ``` c++
499 #include <iostream>
500 code
501 ```
502
503 ```  vim
504 let g:a = 1
505 ```
506
507 ```     ruby
508 def a
509 end
510 ```
511
512 ```
513 ruby
514 class B
515 end
516 ```
517
518 Execute (fenced code block syntax with a language specifier after whitespace):
519   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
520   call b:func(0)
521   AssertEqual SyntaxOf('include'), 'cInclude'
522   AssertEqual SyntaxOf('code'), 'mkdSnippetCPP'
523   AssertEqual SyntaxOf('g:a'), 'vimVar'
524   AssertEqual SyntaxOf('def'), 'rubyDefine'
525   AssertNotEqual SyntaxOf('class'), 'rubyClass'
526
527 Given markdown;
528 ```vim
529 let g:a = 1
530 ```
531
532 ```viml
533 let g:b = 1
534 ```
535
536 Execute (fenced code block syntax with alias language specifier):
537   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
538   call b:func(0)
539   AssertEqual SyntaxOf('g:a'), 'vimVar'
540   AssertEqual SyntaxOf('g:b'), 'vimVar'
541
542 Given markdown;
543 ```csharp
544 var s = "foo";
545 ```
546
547 Execute (fenced code block languages setting):
548   let g:vim_markdown_fenced_languages = ['csharp=cs']
549   source ../ftplugin/markdown.vim
550   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
551   call b:func(0)
552   AssertEqual SyntaxOf('foo'), 'csString'
553   unlet g:vim_markdown_fenced_languages
554
555 Given markdown;
556 ```vim
557 let g:a = 1
558 ```
559
560 Execute (fenced code block includes language syntax with reopening same buffer):
561   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
562   call b:func(0)
563   split
564   quit
565   edit
566   set filetype=markdown
567   execute "normal! i```vim\<cr>let g:a = 1\<cr>```"
568   call b:func(1)
569   AssertEqual SyntaxOf('g:a'), 'vimVar'
570
571 Given markdown;
572 ```a+b-
573 code
574 ```
575
576 Execute (fenced code block syntax with an unknown language specifier):
577   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
578   call b:func(0)
579   AssertEqual SyntaxOf('code'), 'mkdSnippetA_B_'
580
581 Given markdown;
582 ```
583 =
584 a
585 -
586 ```
587
588 Execute (first = or - in fenced code block is not setex headers):
589   AssertEqual SyntaxOf('='), 'mkdCode'
590   AssertEqual SyntaxOf('-'), 'mkdCode'
591
592 Given markdown;
593 ``` {style=""}
594 a
595 ```
596
597 Execute (fenced code block with extended info strings):
598   AssertEqual SyntaxOf('a'), 'mkdCode'
599
600 # Code Blocks in pre and code tag
601
602 Given markdown;
603 <pre>
604 a
605 </pre>
606
607 Execute (code block in pre tag):
608   AssertEqual SyntaxOf('a'), 'mkdCode'
609
610 Given markdown;
611 <code>
612 a
613 </code>
614
615 Execute (code block in code tag):
616   AssertEqual SyntaxOf('a'), 'mkdCode'
617
618 Given markdown;
619 \<pre\>
620 a
621 \</pre\>
622
623 Execute (not code block in escaped pre tag):
624   AssertNotEqual SyntaxOf('a'), 'mkdCode'
625
626 Given markdown;
627 \<code\>
628 a
629 \</code\>
630
631 Execute (not code block in escaped code tag):
632   AssertNotEqual SyntaxOf('a'), 'mkdCode'
633
634 # Math
635
636 Given markdown;
637 a $x$ b
638 c $$y$$ d
639 \$e\$
640 \$\$f\$\$
641
642 Execute (math):
643   AssertNotEqual SyntaxOf('x')[0:2], 'tex'
644   AssertNotEqual SyntaxOf('y')[0:2], 'tex'
645   let g:vim_markdown_math=1
646   syn off | syn on
647   AssertNotEqual SyntaxOf('a')[0:2], 'tex'
648   AssertNotEqual SyntaxOf('b')[0:2], 'tex'
649   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
650   AssertNotEqual SyntaxOf('d')[0:2], 'tex'
651   AssertNotEqual SyntaxOf('e')[0:2], 'tex'
652   AssertNotEqual SyntaxOf('f')[0:2], 'tex'
653   AssertEqual SyntaxOf('x')[0:2], 'tex'
654   AssertEqual SyntaxOf('y')[0:2], 'tex'
655   let g:vim_markdown_math=0
656   syn off | syn on
657   AssertNotEqual SyntaxOf('x')[0:2], 'tex'
658   AssertNotEqual SyntaxOf('y')[0:2], 'tex'
659
660 Given markdown;
661 a
662
663 $
664 b
665 $
666
667 c
668
669 Execute (multiline math):
670   let g:vim_markdown_math=1
671   syn off | syn on
672   AssertNotEqual SyntaxOf('a')[0:2], 'tex'
673   AssertEqual SyntaxOf('b')[0:2], 'tex'
674   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
675
676 Given markdown;
677 $ \sqrt{a}{b} $
678 $$ \frac{a}{b} $$
679
680 Execute (math tex highlighting):
681   let g:vim_markdown_math=0
682   syn off | syn on
683   AssertNotEqual SyntaxOf('sqrt'), 'texStatement'
684   AssertNotEqual SyntaxOf('frac'), 'texStatement'
685   let g:vim_markdown_math=1
686   syn off | syn on
687   AssertEqual SyntaxOf('sqrt'), 'texStatement'
688   AssertEqual SyntaxOf('frac'), 'texStatement'
689
690 Given markdown;
691 $a b[$ c
692
693 Execute (math ends with $):
694   let g:vim_markdown_math=1
695   syn off | syn on
696   AssertEqual SyntaxOf('a')[0:2], 'tex'
697   AssertEqual SyntaxOf('b')[0:2], 'tex'
698   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
699
700 Given markdown;
701 $$a b[$$ c
702
703 Execute (math ends with $$):
704   let g:vim_markdown_math=1
705   syn off | syn on
706   AssertEqual SyntaxOf('a')[0:2], 'tex'
707   AssertEqual SyntaxOf('b')[0:2], 'tex'
708   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
709
710 Given markdown;
711 $(0 \le 1)$
712
713 Execute (math conceal in $):
714   if has('conceal')
715     setlocal conceallevel=2
716     let g:vim_markdown_math=1
717     syn off | syn on
718     AssertEqual synconcealed(1, 1)[0], 1, '$'
719     AssertEqual synconcealed(1, 2)[0], 0
720     AssertEqual synconcealed(1, 3)[0], 0
721     AssertEqual synconcealed(1, 4)[0], 0
722     AssertEqual synconcealed(1, 5)[0], 1, '\le'
723     AssertEqual synconcealed(1, 6)[0], 1
724     AssertEqual synconcealed(1, 7)[0], 1
725     AssertEqual synconcealed(1, 8)[0], 0
726     AssertEqual synconcealed(1, 9)[0], 0
727     AssertEqual synconcealed(1, 10)[0], 0
728     AssertEqual synconcealed(1, 11)[0], 1, '$'
729     setlocal conceallevel=0
730   endif
731
732 Given markdown;
733 $$
734 \omega
735 0 \le 1
736 $$
737
738 Execute (math conceal in $$):
739   if has('conceal')
740     setlocal conceallevel=2
741     let g:vim_markdown_math=1
742     syn off | syn on
743     AssertEqual synconcealed(1, 1)[0], 1, '$$'
744     AssertEqual synconcealed(2, 1)[0], 1, '\omega'
745     AssertEqual synconcealed(3, 1)[0], 0, '0'
746     AssertEqual synconcealed(3, 3)[0], 1, '\le'
747     AssertEqual synconcealed(3, 7)[0], 0, '1'
748     AssertEqual synconcealed(4, 1)[0], 1, '$$'
749     setlocal conceallevel=0
750   endif
751
752 # YAML frontmatter
753
754 Given markdown;
755 ---
756 a: b
757 ---
758
759 Execute (YAML frontmatter is controlled by the option):
760   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
761   let g:vim_markdown_frontmatter=1
762   syn off | syn on
763   AssertEqual SyntaxOf('a')[0:3], 'yaml'
764   let g:vim_markdown_frontmatter=0
765   syn off | syn on
766   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
767
768 Given markdown;
769
770 ---
771 a: b
772 ---
773
774 Execute (YAML frontmatter only works if it's the first thing in the file):
775   let g:vim_markdown_frontmatter=1
776   syn off | syn on
777   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
778
779 Given markdown;
780 ---
781 a: b
782 ---
783
784 ---
785
786 Execute (rules are not mistaken by YAML frontmatter delimiters):
787   let g:vim_markdown_frontmatter=1
788   syn off | syn on
789   AssertEqual SyntaxAt(5, 1), 'mkdRule'
790   unlet g:vim_markdown_frontmatter
791
792 # TOML frontmatter
793
794 Given markdown;
795 +++
796 a = "b"
797 +++
798
799 Execute (TOML frontmatter is controlled by the option):
800   syn off | syn on
801   AssertNotEqual SyntaxOf('b'), 'tomlString'
802   let g:vim_markdown_toml_frontmatter=1
803   syn off | syn on
804   AssertEqual SyntaxOf('b'), 'tomlString'
805   let g:vim_markdown_toml_frontmatter=0
806   syn off | syn on
807   AssertNotEqual SyntaxOf('b'), 'tomlString'
808
809 Given markdown;
810
811 +++
812 a = "b"
813 +++
814
815 Execute (TOML frontmatter only works if it's the first thing in the file):
816   let g:vim_markdown_toml_frontmatter=1
817   syn off | syn on
818   AssertNotEqual SyntaxOf('b'), 'tomlString'
819   unlet g:vim_markdown_toml_frontmatter
820
821 # JSON frontmatter
822
823 Given markdown;
824 {
825   "a": "b"
826 }
827
828 Execute (JSON frontmatter is controlled by the option):
829   syn off | syn on
830   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
831   let g:vim_markdown_json_frontmatter=1
832   syn off | syn on
833   AssertEqual SyntaxOf('a'), 'jsonKeyword'
834   let g:vim_markdown_json_frontmatter=0
835   syn off | syn on
836   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
837
838 Given markdown;
839
840 {
841   "a": "b"
842 }
843
844 Execute (JSON frontmatter only works if it's the first thing in the file):
845   let g:vim_markdown_json_frontmatter=1
846   syn off | syn on
847   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
848   unlet g:vim_markdown_json_frontmatter
849
850 # Header
851
852 Given markdown;
853 # #a
854 ccc
855
856 ## #b
857 ddd
858
859 Execute (header title starts with #):
860   AssertEqual SyntaxOf('a'), 'htmlH1'
861   AssertEqual SyntaxOf('b'), 'htmlH2'
862
863 Given markdown;
864 # h1 space
865
866 #h1 nospace
867
868 #  h1 2 spaces
869
870 # h1 trailing hash #
871
872 ## h2 space
873
874 ##h2 nospace
875
876 ## h2 trailing hash ##
877
878 ### h3 space
879
880 ###h3 nospace
881
882 ### h3 trailing hash ###
883
884 #### h4
885
886 ##### h5
887
888 ###### h6
889
890 Execute (atx headers):
891   AssertEqual SyntaxOf('# h1 space'), 'htmlH1'
892   AssertEqual SyntaxOf('#h1 nospace'), 'htmlH1'
893   AssertEqual SyntaxOf('#  h1 2 spaces'), 'htmlH1'
894   AssertEqual SyntaxOf('# h1 trailing hash #'), 'htmlH1'
895   AssertEqual SyntaxOf('## h2 space'), 'htmlH2'
896   AssertEqual SyntaxOf('##h2 nospace'), 'htmlH2'
897   AssertEqual SyntaxOf('## h2 trailing hash ##'), 'htmlH2'
898   AssertEqual SyntaxOf('### h3 space'), 'htmlH3'
899   AssertEqual SyntaxOf('###h3 nospace'), 'htmlH3'
900   AssertEqual SyntaxOf('### h3 trailing hash ###'), 'htmlH3'
901   AssertEqual SyntaxOf('#### h4'), 'htmlH4'
902   AssertEqual SyntaxOf('##### h5'), 'htmlH5'
903   AssertEqual SyntaxOf('###### h6'), 'htmlH6'
904
905 Given markdown;
906 # h1 before h2
907
908 ## h2 between h1s
909
910 # h1 after h2
911
912 Execute (atx headers relative positions):
913   AssertEqual SyntaxOf('# h1 before h2'), 'htmlH1'
914   AssertEqual SyntaxOf('## h2 between h1s'), 'htmlH2'
915   AssertEqual SyntaxOf('# h1 after h2'), 'htmlH1'
916
917 Given markdown;
918 setex h1
919 ========
920
921 setex h2
922 --------
923
924 setex h1 single punctuation
925 =
926
927 setex h1 punctuation longer than header
928 ================================
929
930 Execute (setex headers):
931   AssertEqual SyntaxOf('setex h1'), 'htmlH1'
932   AssertEqual SyntaxOf('^========$'), 'htmlH1'
933   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
934   AssertEqual SyntaxOf('--------'), 'htmlH2'
935   AssertEqual SyntaxOf('setex h1 single punctuation'), 'htmlH1'
936   AssertEqual SyntaxOf('^=$'), 'htmlH1'
937   AssertEqual SyntaxOf('setex h1 punctuation longer than header'), 'htmlH1'
938   AssertEqual SyntaxOf('^================================$'), 'htmlH1'
939
940 Given markdown;
941 - not Setex
942 - because list
943
944 Execute (prevent list vs Setex confusion):
945   AssertNotEqual SyntaxOf('- not Setex'), 'htmlH2'
946   AssertNotEqual SyntaxOf('- becuase list'), 'htmlH2'
947
948 Given markdown;
949 setex h1 before atx
950 ===================
951
952 ## atx h2
953
954 ### atx h3
955
956 # atx h1
957
958 setex h2
959 ------------------
960
961 ### atx h3 2
962
963 Execute (mixed atx and setex headers):
964   AssertEqual SyntaxOf('setex h1 before atx'), 'htmlH1'
965   AssertEqual SyntaxOf('==================='), 'htmlH1'
966   AssertEqual SyntaxOf('## atx h2'), 'htmlH2'
967   AssertEqual SyntaxOf('### atx h3'), 'htmlH3'
968   AssertEqual SyntaxOf('# atx h1'), 'htmlH1'
969   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
970   AssertEqual SyntaxOf('------------------'), 'htmlH2'
971
972 # List
973
974 Given markdown;
975 - a & b
976 1. c > d
977
978 Execute (& and > are not marked as htmlError in lists):
979   AssertEqual SyntaxOf('-'), 'mkdListItem'
980   AssertEqual SyntaxOf('1.'), 'mkdListItem'
981   AssertNotEqual SyntaxOf('&'), 'htmlError'
982   AssertNotEqual SyntaxOf('>'), 'htmlError'
983
984 Given markdown;
985 1. a  
986 2. b
987
988 Execute (list after line break):
989   AssertEqual SyntaxOf('1'), 'mkdListItem'
990   AssertEqual SyntaxOf('2'), 'mkdListItem'
991
992 # HTML
993
994 Given markdown;
995 a
996
997 <p>b</p>
998
999 - <span>c</span>
1000
1001 Execute (HTML tag in text):
1002   AssertEqual SyntaxOf('p'), 'htmlTagName'
1003   AssertEqual SyntaxOf('<p>'), 'htmlTag'
1004   AssertEqual SyntaxOf('</p>'), 'htmlEndTag'
1005   AssertEqual SyntaxOf('span'), 'htmlTagName'
1006   AssertEqual SyntaxOf('<span>'), 'htmlTag'
1007   AssertEqual SyntaxOf('</span>'), 'htmlEndTag'