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

c55ce76dbf6c5dd2edbafc33503d6ff6d7b1dff4
[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   setlocal conceallevel=2
197   AssertEqual synconcealed(1, 1)[0], 1
198   AssertEqual synconcealed(1, 2)[0], 0
199   AssertEqual synconcealed(1, 3)[0], 1
200   AssertEqual synconcealed(1, 4)[0], 1
201   AssertEqual synconcealed(1, 4)[0], 1
202   AssertEqual synconcealed(1, 5)[0], 1
203   AssertEqual synconcealed(1, 6)[0], 1
204   setlocal conceallevel=0
205
206 # Autolinks
207
208 Given markdown;
209 a <http://b> c
210
211 Execute (autolink):
212   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
213   AssertEqual SyntaxOf('<'), 'mkdDelimiter'
214   AssertEqual SyntaxOf('b'), 'mkdInlineURL'
215   AssertEqual SyntaxOf('>'), 'mkdDelimiter'
216   AssertNotEqual SyntaxOf('c'), 'mkdInlineURL'
217
218 Given markdown;
219 <HtTp://a>
220
221 Execute (autolink with scheme case is insensitive):
222   AssertEqual SyntaxOf('a'), 'mkdInlineURL'
223
224 Given markdown;
225 <a>
226
227 Execute (autolink without scheme is not a link):
228   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
229
230 Given markdown;
231 < http://a >
232 <http://b c>
233 <http://d
234 e>
235
236 Execute (autolink with space is not a link):
237   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
238   AssertNotEqual SyntaxOf('b'), 'mkdInlineURL'
239   AssertNotEqual SyntaxOf('c'), 'mkdInlineURL'
240   AssertNotEqual SyntaxOf('d'), 'mkdInlineURL'
241   AssertNotEqual SyntaxOf('e'), 'mkdInlineURL'
242
243 Given markdown;
244 \<http://a>
245
246 Execute (autolinks can be backslash escaped):
247   AssertNotEqual SyntaxOf('<'), 'mkdDelimiter'
248
249 Given markdown;
250 a (http://b.bb) c
251
252 Execute (autolink in parenthesis):
253   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
254   AssertEqual SyntaxOf('('), 'mkdDelimiter'
255   AssertEqual SyntaxOf('b'), 'mkdInlineURL'
256   AssertEqual SyntaxOf(')'), 'mkdDelimiter'
257   AssertNotEqual SyntaxOf('c'), 'mkdInlineURL'
258
259 Given markdown;
260 [![a](http://b)](http://c)
261
262 Execute (autolink in link text):
263   AssertEqual SyntaxOf('!'), 'mkdDelimiter'
264   AssertEqual SyntaxOf('a'), 'mkdLink'
265   AssertEqual SyntaxOf('b'), 'mkdURL'
266   AssertEqual SyntaxOf('c'), 'mkdURL'
267
268 # Code Blocks
269
270 Given markdown;
271 ~~~
272 code
273 ~~~
274
275 Execute (code blocks can be fenced with tildes):
276   AssertEqual SyntaxOf('c'), 'mkdCode'
277
278 Given markdown;
279 ~~~~
280 code
281 ~~~~~
282
283 Execute (code blocks can be fenced with tildes longer than 3):
284   AssertEqual SyntaxOf('c'), 'mkdCode'
285
286 Given markdown;
287 ````
288 code
289 `````
290
291 Execute (code blocks can be fenced with backticks longer than 3):
292   AssertEqual SyntaxOf('c'), 'mkdCode'
293
294 Given markdown;
295 ~~~ruby
296 code
297 ~~~
298
299 Execute (code blocks can have a language specifier):
300   AssertEqual SyntaxOf('c'), 'mkdCode'
301
302 Given markdown;
303 ```c++
304 code
305 ```
306
307 text
308
309 Execute (code blocks can be fenced with backticks and a language specifier):
310   AssertEqual SyntaxOf('code'), 'mkdCode'
311   AssertNotEqual SyntaxOf('text'), 'mkdCode'
312
313 # Indent Code Blocks
314
315 Given markdown;
316 a
317
318     b
319     c
320
321 Execute (indent code blocks):
322   AssertNotEqual SyntaxOf('a'), 'mkdCode'
323   AssertEqual SyntaxOf('b'), 'mkdCode'
324   AssertEqual SyntaxOf('c'), 'mkdCode'
325
326 Given markdown;
327 # a
328
329 b
330
331     c
332
333 Execute (indent code blocks after header):
334   AssertNotEqual SyntaxOf('a'), 'mkdCode'
335   AssertNotEqual SyntaxOf('b'), 'mkdCode'
336   AssertEqual SyntaxOf('c'), 'mkdCode'
337
338 Given markdown;
339 -   a
340
341     b
342
343         c
344
345 Execute (indent code blocks after list):
346   AssertNotEqual SyntaxOf('a'), 'mkdCode'
347   AssertNotEqual SyntaxOf('b'), 'mkdCode'
348   AssertEqual SyntaxOf('c'), 'mkdCode'
349
350 Given markdown;
351     a
352     b
353
354 Execute (indent code block at beginning of file):
355   AssertEqual SyntaxOf('a'), 'mkdCode'
356   AssertEqual SyntaxOf('b'), 'mkdCode'
357
358 Given markdown;
359 ```c++
360 #include <iostream>
361 code
362 ```
363
364 ```ruby
365 def a
366 end
367 ```
368
369 Execute (fenced code block syntax with a language specifier):
370   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
371   call b:func(0)
372   AssertEqual SyntaxOf('include'), 'cInclude'
373   AssertEqual SyntaxOf('code'), 'mkdSnippetCPP'
374   AssertEqual SyntaxOf('def'), 'rubyDefine'
375
376 Given markdown;
377 ```a+b-
378 code
379 ```
380
381 Execute (fenced code block syntax with an unknown language specifier):
382   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
383   call b:func(0)
384   AssertEqual SyntaxOf('code'), 'mkdSnippetA_B_'
385
386
387 Given markdown;
388 ```
389 =
390 a
391 -
392 ```
393
394 Execute (first = or - in fenced code block is not setex headers):
395   AssertEqual SyntaxOf('='), 'mkdCode'
396   AssertEqual SyntaxOf('-'), 'mkdCode'
397
398 # Code Blocks in pre and code tag
399
400 Given markdown;
401 <pre>
402 a
403 </pre>
404
405 Execute (code block in pre tag):
406   AssertEqual SyntaxOf('a'), 'mkdCode'
407
408 Given markdown;
409 <code>
410 a
411 </code>
412
413 Execute (code block in code tag):
414   AssertEqual SyntaxOf('a'), 'mkdCode'
415
416 Given markdown;
417 \<pre\>
418 a
419 \</pre\>
420
421 Execute (not code block in escaped pre tag):
422   AssertNotEqual SyntaxOf('a'), 'mkdCode'
423
424 Given markdown;
425 \<code\>
426 a
427 \</code\>
428
429 Execute (not code block in escaped code tag):
430   AssertNotEqual SyntaxOf('a'), 'mkdCode'
431
432 # Math
433
434 Given markdown;
435 a $x$ b
436 c $$y$$ d
437 \$e\$
438 \$\$f\$\$
439
440 Execute (math):
441   AssertNotEqual SyntaxOf('x'), 'mkdMath'
442   AssertNotEqual SyntaxOf('y'), 'mkdMath'
443   let g:vim_markdown_math=1
444   syn off | syn on
445   AssertNotEqual SyntaxOf('a'), 'mkdMath'
446   AssertNotEqual SyntaxOf('b'), 'mkdMath'
447   AssertNotEqual SyntaxOf('c'), 'mkdMath'
448   AssertNotEqual SyntaxOf('d'), 'mkdMath'
449   AssertNotEqual SyntaxOf('e'), 'mkdMath'
450   AssertNotEqual SyntaxOf('f'), 'mkdMath'
451   AssertEqual SyntaxOf('x'), 'mkdMath'
452   AssertEqual SyntaxOf('y'), 'mkdMath'
453   let g:vim_markdown_math=0
454   syn off | syn on
455   AssertNotEqual SyntaxOf('x'), 'mkdMath'
456   AssertNotEqual SyntaxOf('y'), 'mkdMath'
457
458 Given markdown;
459 a
460
461 $
462 b
463 $
464
465 c
466
467 Execute (multiline math):
468   let g:vim_markdown_math=1
469   syn off | syn on
470   AssertNotEqual SyntaxOf('a'), 'mkdMath'
471   AssertEqual SyntaxOf('b'), 'mkdMath'
472   AssertNotEqual SyntaxOf('c'), 'mkdMath'
473
474 Given markdown;
475 $ \sqrt{a}{b} $
476 $$ \frac{a}{b} $$
477
478 Execute (math tex highlighting):
479   let g:vim_markdown_math=0
480   syn off | syn on
481   AssertNotEqual SyntaxOf('sqrt'), 'texStatement'
482   AssertNotEqual SyntaxOf('frac'), 'texStatement'
483   let g:vim_markdown_math=1
484   syn off | syn on
485   AssertEqual SyntaxOf('sqrt'), 'texStatement'
486   AssertEqual SyntaxOf('frac'), 'texStatement'
487
488 # YAML frontmatter
489
490 Given markdown;
491 ---
492 a: b
493 ---
494
495 Execute (YAML frontmatter is controlled by the option):
496   AssertNotEqual SyntaxOf('a'), 'yamlBlockMappingKey'
497   let g:vim_markdown_frontmatter=1
498   syn off | syn on
499   AssertEqual SyntaxOf('a'), 'yamlBlockMappingKey'
500   let g:vim_markdown_frontmatter=0
501   syn off | syn on
502   AssertNotEqual SyntaxOf('a'), 'yamlBlockMappingKey'
503
504 Given markdown;
505
506 ---
507 a: b
508 ---
509
510 Execute (YAML frontmatter only works if it's the first thing in the file):
511   let g:vim_markdown_frontmatter=1
512   syn off | syn on
513   AssertNotEqual SyntaxOf('a'), 'yamlBlockMappingKey'
514
515 Given markdown;
516 ---
517 a: b
518 ---
519
520 ---
521
522 Execute (rules are not mistaken by YAML frontmatter delimiters):
523   let g:vim_markdown_frontmatter=1
524   syn off | syn on
525   AssertEqual SyntaxAt(5, 1), 'mkdRule'
526   unlet g:vim_markdown_frontmatter
527
528 # TOML frontmatter
529
530 Given markdown;
531 +++
532 a = "b"
533 +++
534
535 Execute (TOML frontmatter is controlled by the option):
536   syn off | syn on
537   AssertNotEqual SyntaxOf('b'), 'tomlString'
538   let g:vim_markdown_toml_frontmatter=1
539   syn off | syn on
540   AssertEqual SyntaxOf('b'), 'tomlString'
541   let g:vim_markdown_toml_frontmatter=0
542   syn off | syn on
543   AssertNotEqual SyntaxOf('b'), 'tomlString'
544
545 Given markdown;
546
547 +++
548 a = "b"
549 +++
550
551 Execute (TOML frontmatter only works if it's the first thing in the file):
552   let g:vim_markdown_toml_frontmatter=1
553   syn off | syn on
554   AssertNotEqual SyntaxOf('b'), 'tomlString'
555   unlet g:vim_markdown_toml_frontmatter
556
557 # JSON frontmatter
558
559 Given markdown;
560 {
561   "a": "b"
562 }
563
564 Execute (JSON frontmatter is controlled by the option):
565   syn off | syn on
566   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
567   let g:vim_markdown_json_frontmatter=1
568   syn off | syn on
569   AssertEqual SyntaxOf('a'), 'jsonKeyword'
570   let g:vim_markdown_json_frontmatter=0
571   syn off | syn on
572   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
573
574 Given markdown;
575
576 {
577   "a": "b"
578 }
579
580 Execute (JSON frontmatter only works if it's the first thing in the file):
581   let g:vim_markdown_json_frontmatter=1
582   syn off | syn on
583   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
584   unlet g:vim_markdown_json_frontmatter
585
586 # Header
587
588 Given markdown;
589 # #a
590 ccc
591
592 ## #b
593 ddd
594
595 Execute (header title starts with #):
596   AssertEqual SyntaxOf('a'), 'htmlH1'
597   AssertEqual SyntaxOf('b'), 'htmlH2'
598
599 Given markdown;
600 # h1 space
601
602 #h1 nospace
603
604 #  h1 2 spaces
605
606 # h1 trailing hash #
607
608 ## h2 space
609
610 ##h2 nospace
611
612 ## h2 trailing hash ##
613
614 ### h3 space
615
616 ###h3 nospace
617
618 ### h3 trailing hash ###
619
620 #### h4
621
622 ##### h5
623
624 ###### h6
625
626 Execute (atx headers):
627   AssertEqual SyntaxOf('# h1 space'), 'htmlH1'
628   AssertEqual SyntaxOf('#h1 nospace'), 'htmlH1'
629   AssertEqual SyntaxOf('#  h1 2 spaces'), 'htmlH1'
630   AssertEqual SyntaxOf('# h1 trailing hash #'), 'htmlH1'
631   AssertEqual SyntaxOf('## h2 space'), 'htmlH2'
632   AssertEqual SyntaxOf('##h2 nospace'), 'htmlH2'
633   AssertEqual SyntaxOf('## h2 trailing hash ##'), 'htmlH2'
634   AssertEqual SyntaxOf('### h3 space'), 'htmlH3'
635   AssertEqual SyntaxOf('###h3 nospace'), 'htmlH3'
636   AssertEqual SyntaxOf('### h3 trailing hash ###'), 'htmlH3'
637   AssertEqual SyntaxOf('#### h4'), 'htmlH4'
638   AssertEqual SyntaxOf('##### h5'), 'htmlH5'
639   AssertEqual SyntaxOf('###### h6'), 'htmlH6'
640
641 Given markdown;
642 # h1 before h2
643
644 ## h2 between h1s
645
646 # h1 after h2
647
648 Execute (atx headers relative positions):
649   AssertEqual SyntaxOf('# h1 before h2'), 'htmlH1'
650   AssertEqual SyntaxOf('## h2 between h1s'), 'htmlH2'
651   AssertEqual SyntaxOf('# h1 after h2'), 'htmlH1'
652
653 Given markdown;
654 setex h1
655 ========
656
657 setex h2
658 --------
659
660 setex h1 single punctuation
661 =
662
663 setex h1 punctuation longer than header
664 ================================
665
666 Execute (setex headers):
667   AssertEqual SyntaxOf('setex h1'), 'htmlH1'
668   AssertEqual SyntaxOf('^========$'), 'htmlH1'
669   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
670   AssertEqual SyntaxOf('--------'), 'htmlH2'
671   AssertEqual SyntaxOf('setex h1 single punctuation'), 'htmlH1'
672   AssertEqual SyntaxOf('^=$'), 'htmlH1'
673   AssertEqual SyntaxOf('setex h1 punctuation longer than header'), 'htmlH1'
674   AssertEqual SyntaxOf('^================================$'), 'htmlH1'
675
676 Given markdown;
677 - not Setex
678 - because list
679
680 Execute (prevent list vs Setex confusion):
681   AssertNotEqual SyntaxOf('- not Setex'), 'htmlH2'
682   AssertNotEqual SyntaxOf('- becuase list'), 'htmlH2'
683
684 Given markdown;
685 setex h1 before atx
686 ===================
687
688 ## atx h2
689
690 ### atx h3
691
692 # atx h1
693
694 setex h2
695 ------------------
696
697 ### atx h3 2
698
699 Execute (mixed atx and setex headers):
700   AssertEqual SyntaxOf('setex h1 before atx'), 'htmlH1'
701   AssertEqual SyntaxOf('==================='), 'htmlH1'
702   AssertEqual SyntaxOf('## atx h2'), 'htmlH2'
703   AssertEqual SyntaxOf('### atx h3'), 'htmlH3'
704   AssertEqual SyntaxOf('# atx h1'), 'htmlH1'
705   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
706   AssertEqual SyntaxOf('------------------'), 'htmlH2'
707
708 # List
709
710 Given markdown;
711 - a & b
712 1. c > d
713
714 Execute (& and > are not marked as htmlError in lists):
715   AssertEqual SyntaxOf('-'), 'mkdListItem'
716   AssertEqual SyntaxOf('1.'), 'mkdListItem'
717   AssertNotEqual SyntaxOf('&'), 'htmlError'
718   AssertNotEqual SyntaxOf('>'), 'htmlError'
719
720 Given markdown;
721 1. a  
722 2. b
723
724 Execute (list after line break):
725   AssertEqual SyntaxOf('1'), 'mkdListItem'
726   AssertEqual SyntaxOf('2'), 'mkdListItem'
727
728 # HTML
729
730 Given markdown;
731 a
732
733 <p>b</p>
734
735 - <span>c</span>
736
737 Execute (HTML tag in text):
738   AssertEqual SyntaxOf('p'), 'htmlTagName'
739   AssertEqual SyntaxOf('<p>'), 'htmlTag'
740   AssertEqual SyntaxOf('</p>'), 'htmlEndTag'
741   AssertEqual SyntaxOf('span'), 'htmlTagName'
742   AssertEqual SyntaxOf('<span>'), 'htmlTag'
743   AssertEqual SyntaxOf('</span>'), 'htmlEndTag'