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