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