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