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