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 Given markdown;
 399 ``` {style=""}
 400 a
 401 ```
 402
 403 Execute (fenced code block with extended info strings):
 404   AssertEqual SyntaxOf('a'), 'mkdCode'
 405
 406 # Code Blocks in pre and code tag
 407
 408 Given markdown;
 409 <pre>
 410 a
 411 </pre>
 412
 413 Execute (code block in pre tag):
 414   AssertEqual SyntaxOf('a'), 'mkdCode'
 415
 416 Given markdown;
 417 <code>
 418 a
 419 </code>
 420
 421 Execute (code block in code tag):
 422   AssertEqual SyntaxOf('a'), 'mkdCode'
 423
 424 Given markdown;
 425 \<pre\>
 426 a
 427 \</pre\>
 428
 429 Execute (not code block in escaped pre tag):
 430   AssertNotEqual SyntaxOf('a'), 'mkdCode'
 431
 432 Given markdown;
 433 \<code\>
 434 a
 435 \</code\>
 436
 437 Execute (not code block in escaped code tag):
 438   AssertNotEqual SyntaxOf('a'), 'mkdCode'
 439
 440 # Math
 441
 442 Given markdown;
 443 a $x$ b
 444 c $$y$$ d
 445 \$e\$
 446 \$\$f\$\$
 447
 448 Execute (math):
 449   AssertNotEqual SyntaxOf('x'), 'mkdMath'
 450   AssertNotEqual SyntaxOf('y'), 'mkdMath'
 451   let g:vim_markdown_math=1
 452   syn off | syn on
 453   AssertNotEqual SyntaxOf('a'), 'mkdMath'
 454   AssertNotEqual SyntaxOf('b'), 'mkdMath'
 455   AssertNotEqual SyntaxOf('c'), 'mkdMath'
 456   AssertNotEqual SyntaxOf('d'), 'mkdMath'
 457   AssertNotEqual SyntaxOf('e'), 'mkdMath'
 458   AssertNotEqual SyntaxOf('f'), 'mkdMath'
 459   AssertEqual SyntaxOf('x'), 'mkdMath'
 460   AssertEqual SyntaxOf('y'), 'mkdMath'
 461   let g:vim_markdown_math=0
 462   syn off | syn on
 463   AssertNotEqual SyntaxOf('x'), 'mkdMath'
 464   AssertNotEqual SyntaxOf('y'), 'mkdMath'
 465
 466 Given markdown;
 467 a
 468
 469 $
 470 b
 471 $
 472
 473 c
 474
 475 Execute (multiline math):
 476   let g:vim_markdown_math=1
 477   syn off | syn on
 478   AssertNotEqual SyntaxOf('a'), 'mkdMath'
 479   AssertEqual SyntaxOf('b'), 'mkdMath'
 480   AssertNotEqual SyntaxOf('c'), 'mkdMath'
 481
 482 Given markdown;
 483 $ \sqrt{a}{b} $
 484 $$ \frac{a}{b} $$
 485
 486 Execute (math tex highlighting):
 487   let g:vim_markdown_math=0
 488   syn off | syn on
 489   AssertNotEqual SyntaxOf('sqrt'), 'texStatement'
 490   AssertNotEqual SyntaxOf('frac'), 'texStatement'
 491   let g:vim_markdown_math=1
 492   syn off | syn on
 493   AssertEqual SyntaxOf('sqrt'), 'texStatement'
 494   AssertEqual SyntaxOf('frac'), 'texStatement'
 495
 496 # YAML frontmatter
 497
 498 Given markdown;
 499 ---
 500 a: b
 501 ---
 502
 503 Execute (YAML frontmatter is controlled by the option):
 504   AssertNotEqual SyntaxOf('a'), 'yamlBlockMappingKey'
 505   let g:vim_markdown_frontmatter=1
 506   syn off | syn on
 507   AssertEqual SyntaxOf('a'), 'yamlBlockMappingKey'
 508   let g:vim_markdown_frontmatter=0
 509   syn off | syn on
 510   AssertNotEqual SyntaxOf('a'), 'yamlBlockMappingKey'
 511
 512 Given markdown;
 513
 514 ---
 515 a: b
 516 ---
 517
 518 Execute (YAML frontmatter only works if it's the first thing in the file):
 519   let g:vim_markdown_frontmatter=1
 520   syn off | syn on
 521   AssertNotEqual SyntaxOf('a'), 'yamlBlockMappingKey'
 522
 523 Given markdown;
 524 ---
 525 a: b
 526 ---
 527
 528 ---
 529
 530 Execute (rules are not mistaken by YAML frontmatter delimiters):
 531   let g:vim_markdown_frontmatter=1
 532   syn off | syn on
 533   AssertEqual SyntaxAt(5, 1), 'mkdRule'
 534   unlet g:vim_markdown_frontmatter
 535
 536 # TOML frontmatter
 537
 538 Given markdown;
 539 +++
 540 a = "b"
 541 +++
 542
 543 Execute (TOML frontmatter is controlled by the option):
 544   syn off | syn on
 545   AssertNotEqual SyntaxOf('b'), 'tomlString'
 546   let g:vim_markdown_toml_frontmatter=1
 547   syn off | syn on
 548   AssertEqual SyntaxOf('b'), 'tomlString'
 549   let g:vim_markdown_toml_frontmatter=0
 550   syn off | syn on
 551   AssertNotEqual SyntaxOf('b'), 'tomlString'
 552
 553 Given markdown;
 554
 555 +++
 556 a = "b"
 557 +++
 558
 559 Execute (TOML frontmatter only works if it's the first thing in the file):
 560   let g:vim_markdown_toml_frontmatter=1
 561   syn off | syn on
 562   AssertNotEqual SyntaxOf('b'), 'tomlString'
 563   unlet g:vim_markdown_toml_frontmatter
 564
 565 # JSON frontmatter
 566
 567 Given markdown;
 568 {
 569   "a": "b"
 570 }
 571
 572 Execute (JSON frontmatter is controlled by the option):
 573   syn off | syn on
 574   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
 575   let g:vim_markdown_json_frontmatter=1
 576   syn off | syn on
 577   AssertEqual SyntaxOf('a'), 'jsonKeyword'
 578   let g:vim_markdown_json_frontmatter=0
 579   syn off | syn on
 580   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
 581
 582 Given markdown;
 583
 584 {
 585   "a": "b"
 586 }
 587
 588 Execute (JSON frontmatter only works if it's the first thing in the file):
 589   let g:vim_markdown_json_frontmatter=1
 590   syn off | syn on
 591   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
 592   unlet g:vim_markdown_json_frontmatter
 593
 594 # Header
 595
 596 Given markdown;
 597 # #a
 598 ccc
 599
 600 ## #b
 601 ddd
 602
 603 Execute (header title starts with #):
 604   AssertEqual SyntaxOf('a'), 'htmlH1'
 605   AssertEqual SyntaxOf('b'), 'htmlH2'
 606
 607 Given markdown;
 608 # h1 space
 609
 610 #h1 nospace
 611
 612 #  h1 2 spaces
 613
 614 # h1 trailing hash #
 615
 616 ## h2 space
 617
 618 ##h2 nospace
 619
 620 ## h2 trailing hash ##
 621
 622 ### h3 space
 623
 624 ###h3 nospace
 625
 626 ### h3 trailing hash ###
 627
 628 #### h4
 629
 630 ##### h5
 631
 632 ###### h6
 633
 634 Execute (atx headers):
 635   AssertEqual SyntaxOf('# h1 space'), 'htmlH1'
 636   AssertEqual SyntaxOf('#h1 nospace'), 'htmlH1'
 637   AssertEqual SyntaxOf('#  h1 2 spaces'), 'htmlH1'
 638   AssertEqual SyntaxOf('# h1 trailing hash #'), 'htmlH1'
 639   AssertEqual SyntaxOf('## h2 space'), 'htmlH2'
 640   AssertEqual SyntaxOf('##h2 nospace'), 'htmlH2'
 641   AssertEqual SyntaxOf('## h2 trailing hash ##'), 'htmlH2'
 642   AssertEqual SyntaxOf('### h3 space'), 'htmlH3'
 643   AssertEqual SyntaxOf('###h3 nospace'), 'htmlH3'
 644   AssertEqual SyntaxOf('### h3 trailing hash ###'), 'htmlH3'
 645   AssertEqual SyntaxOf('#### h4'), 'htmlH4'
 646   AssertEqual SyntaxOf('##### h5'), 'htmlH5'
 647   AssertEqual SyntaxOf('###### h6'), 'htmlH6'
 648
 649 Given markdown;
 650 # h1 before h2
 651
 652 ## h2 between h1s
 653
 654 # h1 after h2
 655
 656 Execute (atx headers relative positions):
 657   AssertEqual SyntaxOf('# h1 before h2'), 'htmlH1'
 658   AssertEqual SyntaxOf('## h2 between h1s'), 'htmlH2'
 659   AssertEqual SyntaxOf('# h1 after h2'), 'htmlH1'
 660
 661 Given markdown;
 662 setex h1
 663 ========
 664
 665 setex h2
 666 --------
 667
 668 setex h1 single punctuation
 669 =
 670
 671 setex h1 punctuation longer than header
 672 ================================
 673
 674 Execute (setex headers):
 675   AssertEqual SyntaxOf('setex h1'), 'htmlH1'
 676   AssertEqual SyntaxOf('^========$'), 'htmlH1'
 677   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
 678   AssertEqual SyntaxOf('--------'), 'htmlH2'
 679   AssertEqual SyntaxOf('setex h1 single punctuation'), 'htmlH1'
 680   AssertEqual SyntaxOf('^=$'), 'htmlH1'
 681   AssertEqual SyntaxOf('setex h1 punctuation longer than header'), 'htmlH1'
 682   AssertEqual SyntaxOf('^================================$'), 'htmlH1'
 683
 684 Given markdown;
 685 - not Setex
 686 - because list
 687
 688 Execute (prevent list vs Setex confusion):
 689   AssertNotEqual SyntaxOf('- not Setex'), 'htmlH2'
 690   AssertNotEqual SyntaxOf('- becuase list'), 'htmlH2'
 691
 692 Given markdown;
 693 setex h1 before atx
 694 ===================
 695
 696 ## atx h2
 697
 698 ### atx h3
 699
 700 # atx h1
 701
 702 setex h2
 703 ------------------
 704
 705 ### atx h3 2
 706
 707 Execute (mixed atx and setex headers):
 708   AssertEqual SyntaxOf('setex h1 before atx'), 'htmlH1'
 709   AssertEqual SyntaxOf('==================='), 'htmlH1'
 710   AssertEqual SyntaxOf('## atx h2'), 'htmlH2'
 711   AssertEqual SyntaxOf('### atx h3'), 'htmlH3'
 712   AssertEqual SyntaxOf('# atx h1'), 'htmlH1'
 713   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
 714   AssertEqual SyntaxOf('------------------'), 'htmlH2'
 715
 716 # List
 717
 718 Given markdown;
 719 - a & b
 720 1. c > d
 721
 722 Execute (& and > are not marked as htmlError in lists):
 723   AssertEqual SyntaxOf('-'), 'mkdListItem'
 724   AssertEqual SyntaxOf('1.'), 'mkdListItem'
 725   AssertNotEqual SyntaxOf('&'), 'htmlError'
 726   AssertNotEqual SyntaxOf('>'), 'htmlError'
 727
 728 Given markdown;
 729 1. a
 730 2. b
 731
 732 Execute (list after line break):
 733   AssertEqual SyntaxOf('1'), 'mkdListItem'
 734   AssertEqual SyntaxOf('2'), 'mkdListItem'
 735
 736 # HTML
 737
 738 Given markdown;
 739 a
 740
 741 <p>b</p>
 742
 743 - <span>c</span>
 744
 745 Execute (HTML tag in text):
 746   AssertEqual SyntaxOf('p'), 'htmlTagName'
 747   AssertEqual SyntaxOf('<p>'), 'htmlTag'
 748   AssertEqual SyntaxOf('</p>'), 'htmlEndTag'
 749   AssertEqual SyntaxOf('span'), 'htmlTagName'
 750   AssertEqual SyntaxOf('<span>'), 'htmlTag'
 751   AssertEqual SyntaxOf('</span>'), 'htmlEndTag'