test/syntax.vader

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