test/syntax.vader

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