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