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

5286b0bd79ac84d2431b01f1a632c59bf4f39796
[etc/vim.git] / test / syntax.vader
1 Given markdown;
2 a **b** c
3
4 Execute (bold):
5   AssertNotEqual SyntaxOf('a'), 'htmlBold'
6   AssertEqual SyntaxOf('b'), 'htmlBold'
7   AssertNotEqual SyntaxOf('c'), 'htmlBold'
8
9 Given markdown;
10 a __b__ c
11
12 Execute (bold):
13   AssertNotEqual SyntaxOf('a'), 'htmlBold'
14   AssertEqual SyntaxOf('b'), 'htmlBold'
15   AssertNotEqual SyntaxOf('c'), 'htmlBold'
16
17 Given markdown;
18 a *b* c
19
20 Execute (italic):
21   AssertNotEqual SyntaxOf('a'), 'htmlItalic'
22   AssertEqual SyntaxOf('b'), 'htmlItalic'
23   AssertNotEqual SyntaxOf('c'), 'htmlItalic'
24
25 Given markdown;
26 a _b_ c
27
28 Execute (italic):
29   AssertNotEqual SyntaxOf('a'), 'htmlItalic'
30   AssertEqual SyntaxOf('b'), 'htmlItalic'
31   AssertNotEqual SyntaxOf('c'), 'htmlItalic'
32
33 Given markdown;
34 _a_b_
35
36 Execute (italic text has underscores):
37   AssertEqual SyntaxOf('a'), 'htmlItalic'
38   AssertEqual SyntaxOf('b'), 'htmlItalic'
39
40 Given markdown;
41 a \*b\* c
42
43 Execute (not italic with escaped asterisks):
44   AssertNotEqual SyntaxOf('a'), 'htmlItalic'
45   AssertNotEqual SyntaxOf('b'), 'htmlItalic'
46   AssertNotEqual SyntaxOf('c'), 'htmlItalic'
47
48 Given markdown;
49 a \_b\_ c
50
51 Execute (not italic with escaped underscores):
52   AssertNotEqual SyntaxOf('a'), 'htmlItalic'
53   AssertNotEqual SyntaxOf('b'), 'htmlItalic'
54   AssertNotEqual SyntaxOf('c'), 'htmlItalic'
55
56 Given markdown;
57 a _b\_c_ d
58
59 Execute (italic with escaped underscores):
60   AssertNotEqual SyntaxOf('a'), 'htmlItalic'
61   AssertEqual SyntaxOf('b'), 'htmlItalic'
62   AssertEqual SyntaxOf('c'), 'htmlItalic'
63   AssertNotEqual SyntaxOf('d'), 'htmlItalic'
64
65 Given markdown;
66 a_b_c
67
68 Execute (not italic underscores within text):
69   AssertNotEqual SyntaxOf('a'), 'htmlItalic'
70   AssertNotEqual SyntaxOf('b'), 'htmlItalic'
71   AssertNotEqual SyntaxOf('c'), 'htmlItalic'
72
73 Given markdown;
74 a *b\*c* d
75
76 Execute (italic with escaped asterisks):
77   AssertNotEqual SyntaxOf('a'), 'htmlItalic'
78   AssertEqual SyntaxOf('b'), 'htmlItalic'
79   AssertEqual SyntaxOf('c'), 'htmlItalic'
80   AssertNotEqual SyntaxOf('d'), 'htmlItalic'
81
82 Given markdown;
83 a __b\_\_c__ d
84
85 Execute (bold with escaped underscores):
86   AssertNotEqual SyntaxOf('a'), 'htmlBold'
87   AssertEqual SyntaxOf('b'), 'htmlBold'
88   AssertEqual SyntaxOf('c'), 'htmlBold'
89   AssertNotEqual SyntaxOf('d'), 'htmlBold'
90
91 Given markdown;
92 _a b
93 c_ d
94
95 Execute (italic with underscores in multiple lines):
96   AssertEqual SyntaxOf('a'), 'htmlItalic'
97   AssertEqual SyntaxOf('b'), 'htmlItalic'
98   AssertEqual SyntaxOf('c'), 'htmlItalic'
99   AssertNotEqual SyntaxOf('d'), 'htmlItalic'
100
101 Given markdown;
102 __a b
103 c__ d
104
105 Execute (bold with underscores in multiple lines):
106   AssertEqual SyntaxOf('a'), 'htmlBold'
107   AssertEqual SyntaxOf('b'), 'htmlBold'
108   AssertEqual SyntaxOf('c'), 'htmlBold'
109   AssertNotEqual SyntaxOf('d'), 'htmlBold'
110
111 Given markdown;
112 ___a b
113 c___ d
114
115 Execute (bold italic with underscores in multiple lines):
116   AssertEqual SyntaxOf('a'), 'htmlBoldItalic'
117   AssertEqual SyntaxOf('b'), 'htmlBoldItalic'
118   AssertEqual SyntaxOf('c'), 'htmlBoldItalic'
119   AssertNotEqual SyntaxOf('d'), 'htmlBoldItalic'
120
121 Given markdown;
122 *a b
123 c* d
124
125 Execute (italic with asterisks in multiple lines):
126   AssertEqual SyntaxOf('a'), 'htmlItalic'
127   AssertEqual SyntaxOf('b'), 'htmlItalic'
128   AssertEqual SyntaxOf('c'), 'htmlItalic'
129   AssertNotEqual SyntaxOf('d'), 'htmlItalic'
130
131 Given markdown;
132 **a b
133 c** d
134
135 Execute (bold with asterisks in multiple lines):
136   AssertEqual SyntaxOf('a'), 'htmlBold'
137   AssertEqual SyntaxOf('b'), 'htmlBold'
138   AssertEqual SyntaxOf('c'), 'htmlBold'
139   AssertNotEqual SyntaxOf('d'), 'htmlBold'
140
141 Given markdown;
142 ***a b
143 c*** d
144
145 Execute (bold italic with asterisks in multiple lines):
146   AssertEqual SyntaxOf('a'), 'htmlBoldItalic'
147   AssertEqual SyntaxOf('b'), 'htmlBoldItalic'
148   AssertEqual SyntaxOf('c'), 'htmlBoldItalic'
149   AssertNotEqual SyntaxOf('d'), 'htmlBoldItalic'
150
151 # Links
152
153 Given markdown;
154 [a](b)
155
156 Execute (link with title):
157   AssertEqual SyntaxOf('a'), 'mkdLink'
158   AssertEqual SyntaxOf('b'), 'mkdURL'
159
160 Given markdown;
161 [a
162 b](c)
163
164 Execute (link text with newline):
165   AssertEqual SyntaxOf('a'), 'mkdLink'
166   AssertEqual SyntaxOf('b'), 'mkdLink'
167   AssertEqual SyntaxOf('c'), 'mkdURL'
168
169 Given markdown;
170 (a)
171
172 (b)
173
174 Execute (parenthesis not in link):
175   AssertNotEqual SyntaxOf('a'), 'mkdURL'
176   AssertNotEqual SyntaxOf('b'), 'mkdURL'
177
178 Given markdown;
179 [a](b) c [d](e)
180
181 Execute (multiple links on a line):
182   AssertNotEqual SyntaxOf('c'), 'mkdLink'
183   AssertNotEqual SyntaxOf('c'), 'mkdURL'
184
185 Given markdown;
186 [a] (b)
187
188 Execute (space is not allowed between link text and parenthesis):
189   AssertNotEqual SyntaxOf('a'), 'mkdLink'
190   AssertNotEqual SyntaxOf('b'), 'mkdURL'
191
192 Given markdown;
193 [a](b)
194
195 Execute (conceal link):
196   if has('conceal')
197     setlocal conceallevel=2
198     AssertEqual synconcealed(1, 1)[0], 1
199     AssertEqual synconcealed(1, 2)[0], 0
200     AssertEqual synconcealed(1, 3)[0], 1
201     AssertEqual synconcealed(1, 4)[0], 1
202     AssertEqual synconcealed(1, 4)[0], 1
203     AssertEqual synconcealed(1, 5)[0], 1
204     AssertEqual synconcealed(1, 6)[0], 1
205     setlocal conceallevel=0
206   endif
207
208 # Autolinks
209
210 Given markdown;
211 a <http://b> c
212
213 Execute (autolink):
214   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
215   AssertEqual SyntaxOf('<'), 'mkdDelimiter'
216   AssertEqual SyntaxOf('b'), 'mkdInlineURL'
217   AssertEqual SyntaxOf('>'), 'mkdDelimiter'
218   AssertNotEqual SyntaxOf('c'), 'mkdInlineURL'
219
220 Given markdown;
221 http://12monkeys.foo
222
223 Execute (autolink with domain starting with a number):
224   AssertEqual SyntaxOf('12monkeys'), 'mkdInlineURL'
225
226 Given markdown;
227 <HtTp://a>
228
229 Execute (autolink with scheme case is insensitive):
230   AssertEqual SyntaxOf('a'), 'mkdInlineURL'
231
232 Given markdown;
233 <a>
234
235 Execute (autolink without scheme is not a link):
236   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
237
238 Given markdown;
239 < http://a >
240 <http://b c>
241 <http://d
242 e>
243
244 Execute (autolink with space is not a link):
245   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
246   AssertNotEqual SyntaxOf('b'), 'mkdInlineURL'
247   AssertNotEqual SyntaxOf('c'), 'mkdInlineURL'
248   AssertNotEqual SyntaxOf('d'), 'mkdInlineURL'
249   AssertNotEqual SyntaxOf('e'), 'mkdInlineURL'
250
251 Given markdown;
252 \<http://a>
253
254 Execute (autolinks can be backslash escaped):
255   AssertNotEqual SyntaxOf('<'), 'mkdDelimiter'
256
257 Given markdown;
258 a (http://b.bb) c
259
260 Execute (autolink in parenthesis):
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 [![a](http://b)](http://c)
269
270 Execute (autolink in link text):
271   AssertEqual SyntaxOf('!'), 'mkdDelimiter'
272   AssertEqual SyntaxOf('a'), 'mkdLink'
273   AssertEqual SyntaxOf('b'), 'mkdURL'
274   AssertEqual SyntaxOf('c'), 'mkdURL'
275
276 # Code Blocks
277
278 Given markdown;
279 ~~~
280 code
281 ~~~
282
283 Execute (code blocks can be fenced with tildes):
284   AssertEqual SyntaxOf('c'), 'mkdCode'
285
286 Given markdown;
287 ~~~~
288 code
289 ~~~~~
290
291 Execute (code blocks can be fenced with tildes longer than 3):
292   AssertEqual SyntaxOf('c'), 'mkdCode'
293
294 Given markdown;
295 ````
296 code
297 `````
298
299 Execute (code blocks can be fenced with backticks longer than 3):
300   AssertEqual SyntaxOf('c'), 'mkdCode'
301
302 Given markdown;
303 ~~~ruby
304 code
305 ~~~
306
307 Execute (code blocks can have a language specifier):
308   AssertEqual SyntaxOf('c'), 'mkdCode'
309
310 Given markdown;
311 ```c++
312 code
313 ```
314
315 text
316
317 Execute (code blocks can be fenced with backticks and a language specifier):
318   AssertEqual SyntaxOf('code'), 'mkdCode'
319   AssertNotEqual SyntaxOf('text'), 'mkdCode'
320
321 # Indent Code Blocks
322
323 Given markdown;
324 a
325
326     b
327     c
328
329 Execute (indent code blocks):
330   AssertNotEqual SyntaxOf('a'), 'mkdCode'
331   AssertEqual SyntaxOf('b'), 'mkdCode'
332   AssertEqual SyntaxOf('c'), 'mkdCode'
333
334 Given markdown;
335 # a
336
337 b
338
339     c
340
341 Execute (indent code blocks after header):
342   AssertNotEqual SyntaxOf('a'), 'mkdCode'
343   AssertNotEqual SyntaxOf('b'), 'mkdCode'
344   AssertEqual SyntaxOf('c'), 'mkdCode'
345
346 Given markdown;
347 -   a
348
349     b
350
351         c
352
353 Execute (indent code blocks after list):
354   AssertNotEqual SyntaxOf('a'), 'mkdCode'
355   AssertNotEqual SyntaxOf('b'), 'mkdCode'
356   AssertEqual SyntaxOf('c'), 'mkdCode'
357
358 Given markdown;
359     a
360     b
361
362 Execute (indent code block at beginning of file):
363   AssertEqual SyntaxOf('a'), 'mkdCode'
364   AssertEqual SyntaxOf('b'), 'mkdCode'
365
366 Given markdown;
367 ```c++
368 #include <iostream>
369 code
370 ```
371
372 ```ruby
373 def a
374 end
375 ```
376
377 Execute (fenced code block syntax with a language specifier):
378   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
379   call b:func(0)
380   AssertEqual SyntaxOf('include'), 'cInclude'
381   AssertEqual SyntaxOf('code'), 'mkdSnippetCPP'
382   AssertEqual SyntaxOf('def'), 'rubyDefine'
383
384 Given markdown;
385 ```vim
386 let g:a = 1
387 ```
388
389 ```viml
390 let g:b = 1
391 ```
392
393 Execute (fenced code block syntax with alias language specifier):
394   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
395   call b:func(0)
396   AssertEqual SyntaxOf('g:a'), 'vimVar'
397   AssertEqual SyntaxOf('g:b'), 'vimVar'
398
399 Given markdown;
400 ```a+b-
401 code
402 ```
403
404 Execute (fenced code block syntax with an unknown language specifier):
405   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
406   call b:func(0)
407   AssertEqual SyntaxOf('code'), 'mkdSnippetA_B_'
408
409 Given markdown;
410 ```
411 =
412 a
413 -
414 ```
415
416 Execute (first = or - in fenced code block is not setex headers):
417   AssertEqual SyntaxOf('='), 'mkdCode'
418   AssertEqual SyntaxOf('-'), 'mkdCode'
419
420 Given markdown;
421 ``` {style=""}
422 a
423 ```
424
425 Execute (fenced code block with extended info strings):
426   AssertEqual SyntaxOf('a'), 'mkdCode'
427
428 # Code Blocks in pre and code tag
429
430 Given markdown;
431 <pre>
432 a
433 </pre>
434
435 Execute (code block in pre tag):
436   AssertEqual SyntaxOf('a'), 'mkdCode'
437
438 Given markdown;
439 <code>
440 a
441 </code>
442
443 Execute (code block in code tag):
444   AssertEqual SyntaxOf('a'), 'mkdCode'
445
446 Given markdown;
447 \<pre\>
448 a
449 \</pre\>
450
451 Execute (not code block in escaped pre tag):
452   AssertNotEqual SyntaxOf('a'), 'mkdCode'
453
454 Given markdown;
455 \<code\>
456 a
457 \</code\>
458
459 Execute (not code block in escaped code tag):
460   AssertNotEqual SyntaxOf('a'), 'mkdCode'
461
462 # Math
463
464 Given markdown;
465 a $x$ b
466 c $$y$$ d
467 \$e\$
468 \$\$f\$\$
469
470 Execute (math):
471   AssertNotEqual SyntaxOf('x'), 'mkdMath'
472   AssertNotEqual SyntaxOf('y'), 'mkdMath'
473   let g:vim_markdown_math=1
474   syn off | syn on
475   AssertNotEqual SyntaxOf('a'), 'mkdMath'
476   AssertNotEqual SyntaxOf('b'), 'mkdMath'
477   AssertNotEqual SyntaxOf('c'), 'mkdMath'
478   AssertNotEqual SyntaxOf('d'), 'mkdMath'
479   AssertNotEqual SyntaxOf('e'), 'mkdMath'
480   AssertNotEqual SyntaxOf('f'), 'mkdMath'
481   AssertEqual SyntaxOf('x'), 'mkdMath'
482   AssertEqual SyntaxOf('y'), 'mkdMath'
483   let g:vim_markdown_math=0
484   syn off | syn on
485   AssertNotEqual SyntaxOf('x'), 'mkdMath'
486   AssertNotEqual SyntaxOf('y'), 'mkdMath'
487
488 Given markdown;
489 a
490
491 $
492 b
493 $
494
495 c
496
497 Execute (multiline math):
498   let g:vim_markdown_math=1
499   syn off | syn on
500   AssertNotEqual SyntaxOf('a'), 'mkdMath'
501   AssertEqual SyntaxOf('b'), 'mkdMath'
502   AssertNotEqual SyntaxOf('c'), 'mkdMath'
503
504 Given markdown;
505 $ \sqrt{a}{b} $
506 $$ \frac{a}{b} $$
507
508 Execute (math tex highlighting):
509   let g:vim_markdown_math=0
510   syn off | syn on
511   AssertNotEqual SyntaxOf('sqrt'), 'texStatement'
512   AssertNotEqual SyntaxOf('frac'), 'texStatement'
513   let g:vim_markdown_math=1
514   syn off | syn on
515   AssertEqual SyntaxOf('sqrt'), 'texStatement'
516   AssertEqual SyntaxOf('frac'), 'texStatement'
517
518 # YAML frontmatter
519
520 Given markdown;
521 ---
522 a: b
523 ---
524
525 Execute (YAML frontmatter is controlled by the option):
526   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
527   let g:vim_markdown_frontmatter=1
528   syn off | syn on
529   AssertEqual SyntaxOf('a')[0:3], 'yaml'
530   let g:vim_markdown_frontmatter=0
531   syn off | syn on
532   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
533
534 Given markdown;
535
536 ---
537 a: b
538 ---
539
540 Execute (YAML frontmatter only works if it's the first thing in the file):
541   let g:vim_markdown_frontmatter=1
542   syn off | syn on
543   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
544
545 Given markdown;
546 ---
547 a: b
548 ---
549
550 ---
551
552 Execute (rules are not mistaken by YAML frontmatter delimiters):
553   let g:vim_markdown_frontmatter=1
554   syn off | syn on
555   AssertEqual SyntaxAt(5, 1), 'mkdRule'
556   unlet g:vim_markdown_frontmatter
557
558 # TOML frontmatter
559
560 Given markdown;
561 +++
562 a = "b"
563 +++
564
565 Execute (TOML frontmatter is controlled by the option):
566   syn off | syn on
567   AssertNotEqual SyntaxOf('b'), 'tomlString'
568   let g:vim_markdown_toml_frontmatter=1
569   syn off | syn on
570   AssertEqual SyntaxOf('b'), 'tomlString'
571   let g:vim_markdown_toml_frontmatter=0
572   syn off | syn on
573   AssertNotEqual SyntaxOf('b'), 'tomlString'
574
575 Given markdown;
576
577 +++
578 a = "b"
579 +++
580
581 Execute (TOML frontmatter only works if it's the first thing in the file):
582   let g:vim_markdown_toml_frontmatter=1
583   syn off | syn on
584   AssertNotEqual SyntaxOf('b'), 'tomlString'
585   unlet g:vim_markdown_toml_frontmatter
586
587 # JSON frontmatter
588
589 Given markdown;
590 {
591   "a": "b"
592 }
593
594 Execute (JSON frontmatter is controlled by the option):
595   syn off | syn on
596   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
597   let g:vim_markdown_json_frontmatter=1
598   syn off | syn on
599   AssertEqual SyntaxOf('a'), 'jsonKeyword'
600   let g:vim_markdown_json_frontmatter=0
601   syn off | syn on
602   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
603
604 Given markdown;
605
606 {
607   "a": "b"
608 }
609
610 Execute (JSON frontmatter only works if it's the first thing in the file):
611   let g:vim_markdown_json_frontmatter=1
612   syn off | syn on
613   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
614   unlet g:vim_markdown_json_frontmatter
615
616 # Header
617
618 Given markdown;
619 # #a
620 ccc
621
622 ## #b
623 ddd
624
625 Execute (header title starts with #):
626   AssertEqual SyntaxOf('a'), 'htmlH1'
627   AssertEqual SyntaxOf('b'), 'htmlH2'
628
629 Given markdown;
630 # h1 space
631
632 #h1 nospace
633
634 #  h1 2 spaces
635
636 # h1 trailing hash #
637
638 ## h2 space
639
640 ##h2 nospace
641
642 ## h2 trailing hash ##
643
644 ### h3 space
645
646 ###h3 nospace
647
648 ### h3 trailing hash ###
649
650 #### h4
651
652 ##### h5
653
654 ###### h6
655
656 Execute (atx headers):
657   AssertEqual SyntaxOf('# h1 space'), 'htmlH1'
658   AssertEqual SyntaxOf('#h1 nospace'), 'htmlH1'
659   AssertEqual SyntaxOf('#  h1 2 spaces'), 'htmlH1'
660   AssertEqual SyntaxOf('# h1 trailing hash #'), 'htmlH1'
661   AssertEqual SyntaxOf('## h2 space'), 'htmlH2'
662   AssertEqual SyntaxOf('##h2 nospace'), 'htmlH2'
663   AssertEqual SyntaxOf('## h2 trailing hash ##'), 'htmlH2'
664   AssertEqual SyntaxOf('### h3 space'), 'htmlH3'
665   AssertEqual SyntaxOf('###h3 nospace'), 'htmlH3'
666   AssertEqual SyntaxOf('### h3 trailing hash ###'), 'htmlH3'
667   AssertEqual SyntaxOf('#### h4'), 'htmlH4'
668   AssertEqual SyntaxOf('##### h5'), 'htmlH5'
669   AssertEqual SyntaxOf('###### h6'), 'htmlH6'
670
671 Given markdown;
672 # h1 before h2
673
674 ## h2 between h1s
675
676 # h1 after h2
677
678 Execute (atx headers relative positions):
679   AssertEqual SyntaxOf('# h1 before h2'), 'htmlH1'
680   AssertEqual SyntaxOf('## h2 between h1s'), 'htmlH2'
681   AssertEqual SyntaxOf('# h1 after h2'), 'htmlH1'
682
683 Given markdown;
684 setex h1
685 ========
686
687 setex h2
688 --------
689
690 setex h1 single punctuation
691 =
692
693 setex h1 punctuation longer than header
694 ================================
695
696 Execute (setex headers):
697   AssertEqual SyntaxOf('setex h1'), 'htmlH1'
698   AssertEqual SyntaxOf('^========$'), 'htmlH1'
699   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
700   AssertEqual SyntaxOf('--------'), 'htmlH2'
701   AssertEqual SyntaxOf('setex h1 single punctuation'), 'htmlH1'
702   AssertEqual SyntaxOf('^=$'), 'htmlH1'
703   AssertEqual SyntaxOf('setex h1 punctuation longer than header'), 'htmlH1'
704   AssertEqual SyntaxOf('^================================$'), 'htmlH1'
705
706 Given markdown;
707 - not Setex
708 - because list
709
710 Execute (prevent list vs Setex confusion):
711   AssertNotEqual SyntaxOf('- not Setex'), 'htmlH2'
712   AssertNotEqual SyntaxOf('- becuase list'), 'htmlH2'
713
714 Given markdown;
715 setex h1 before atx
716 ===================
717
718 ## atx h2
719
720 ### atx h3
721
722 # atx h1
723
724 setex h2
725 ------------------
726
727 ### atx h3 2
728
729 Execute (mixed atx and setex headers):
730   AssertEqual SyntaxOf('setex h1 before atx'), 'htmlH1'
731   AssertEqual SyntaxOf('==================='), 'htmlH1'
732   AssertEqual SyntaxOf('## atx h2'), 'htmlH2'
733   AssertEqual SyntaxOf('### atx h3'), 'htmlH3'
734   AssertEqual SyntaxOf('# atx h1'), 'htmlH1'
735   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
736   AssertEqual SyntaxOf('------------------'), 'htmlH2'
737
738 # List
739
740 Given markdown;
741 - a & b
742 1. c > d
743
744 Execute (& and > are not marked as htmlError in lists):
745   AssertEqual SyntaxOf('-'), 'mkdListItem'
746   AssertEqual SyntaxOf('1.'), 'mkdListItem'
747   AssertNotEqual SyntaxOf('&'), 'htmlError'
748   AssertNotEqual SyntaxOf('>'), 'htmlError'
749
750 Given markdown;
751 1. a  
752 2. b
753
754 Execute (list after line break):
755   AssertEqual SyntaxOf('1'), 'mkdListItem'
756   AssertEqual SyntaxOf('2'), 'mkdListItem'
757
758 # HTML
759
760 Given markdown;
761 a
762
763 <p>b</p>
764
765 - <span>c</span>
766
767 Execute (HTML tag in text):
768   AssertEqual SyntaxOf('p'), 'htmlTagName'
769   AssertEqual SyntaxOf('<p>'), 'htmlTag'
770   AssertEqual SyntaxOf('</p>'), 'htmlEndTag'
771   AssertEqual SyntaxOf('span'), 'htmlTagName'
772   AssertEqual SyntaxOf('<span>'), 'htmlTag'
773   AssertEqual SyntaxOf('</span>'), 'htmlEndTag'