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