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