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

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