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