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')[0:2], 'tex'
 578   AssertNotEqual SyntaxOf('y')[0:2], 'tex'
 579   let g:vim_markdown_math=1
 580   syn off | syn on
 581   AssertNotEqual SyntaxOf('a')[0:2], 'tex'
 582   AssertNotEqual SyntaxOf('b')[0:2], 'tex'
 583   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
 584   AssertNotEqual SyntaxOf('d')[0:2], 'tex'
 585   AssertNotEqual SyntaxOf('e')[0:2], 'tex'
 586   AssertNotEqual SyntaxOf('f')[0:2], 'tex'
 587   AssertEqual SyntaxOf('x')[0:2], 'tex'
 588   AssertEqual SyntaxOf('y')[0:2], 'tex'
 589   let g:vim_markdown_math=0
 590   syn off | syn on
 591   AssertNotEqual SyntaxOf('x')[0:2], 'tex'
 592   AssertNotEqual SyntaxOf('y')[0:2], 'tex'
 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')[0:2], 'tex'
 607   AssertEqual SyntaxOf('b')[0:2], 'tex'
 608   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
 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')[0:2], 'tex'
 631   AssertEqual SyntaxOf('b')[0:2], 'tex'
 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')[0:2], 'tex'
 641   AssertEqual SyntaxOf('b')[0:2], 'tex'
 642   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
 643
 644 Given markdown;
 645 $(0 \le 1)$
 646
 647 Execute (math conceal in $):
 648   if has('conceal')
 649     setlocal conceallevel=2
 650     let g:vim_markdown_math=1
 651     syn off | syn on
 652     AssertEqual synconcealed(1, 1)[0], 1, '$'
 653     AssertEqual synconcealed(1, 2)[0], 0
 654     AssertEqual synconcealed(1, 3)[0], 0
 655     AssertEqual synconcealed(1, 4)[0], 0
 656     AssertEqual synconcealed(1, 5)[0], 1, '\le'
 657     AssertEqual synconcealed(1, 6)[0], 1
 658     AssertEqual synconcealed(1, 7)[0], 1
 659     AssertEqual synconcealed(1, 8)[0], 0
 660     AssertEqual synconcealed(1, 9)[0], 0
 661     AssertEqual synconcealed(1, 10)[0], 0
 662     AssertEqual synconcealed(1, 11)[0], 1, '$'
 663     setlocal conceallevel=0
 664   endif
 665
 666 Given markdown;
 667 $$
 668 \omega
 669 0 \le 1
 670 $$
 671
 672 Execute (math conceal in $$):
 673   if has('conceal')
 674     setlocal conceallevel=2
 675     let g:vim_markdown_math=1
 676     syn off | syn on
 677     AssertEqual synconcealed(1, 1)[0], 1, '$$'
 678     AssertEqual synconcealed(2, 1)[0], 1, '\omega'
 679     AssertEqual synconcealed(3, 1)[0], 0, '0'
 680     AssertEqual synconcealed(3, 3)[0], 1, '\le'
 681     AssertEqual synconcealed(3, 7)[0], 0, '1'
 682     AssertEqual synconcealed(4, 1)[0], 1, '$$'
 683     setlocal conceallevel=0
 684   endif
 685
 686 # YAML frontmatter
 687
 688 Given markdown;
 689 ---
 690 a: b
 691 ---
 692
 693 Execute (YAML frontmatter is controlled by the option):
 694   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
 695   let g:vim_markdown_frontmatter=1
 696   syn off | syn on
 697   AssertEqual SyntaxOf('a')[0:3], 'yaml'
 698   let g:vim_markdown_frontmatter=0
 699   syn off | syn on
 700   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
 701
 702 Given markdown;
 703
 704 ---
 705 a: b
 706 ---
 707
 708 Execute (YAML frontmatter only works if it's the first thing in the file):
 709   let g:vim_markdown_frontmatter=1
 710   syn off | syn on
 711   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
 712
 713 Given markdown;
 714 ---
 715 a: b
 716 ---
 717
 718 ---
 719
 720 Execute (rules are not mistaken by YAML frontmatter delimiters):
 721   let g:vim_markdown_frontmatter=1
 722   syn off | syn on
 723   AssertEqual SyntaxAt(5, 1), 'mkdRule'
 724   unlet g:vim_markdown_frontmatter
 725
 726 # TOML frontmatter
 727
 728 Given markdown;
 729 +++
 730 a = "b"
 731 +++
 732
 733 Execute (TOML frontmatter is controlled by the option):
 734   syn off | syn on
 735   AssertNotEqual SyntaxOf('b'), 'tomlString'
 736   let g:vim_markdown_toml_frontmatter=1
 737   syn off | syn on
 738   AssertEqual SyntaxOf('b'), 'tomlString'
 739   let g:vim_markdown_toml_frontmatter=0
 740   syn off | syn on
 741   AssertNotEqual SyntaxOf('b'), 'tomlString'
 742
 743 Given markdown;
 744
 745 +++
 746 a = "b"
 747 +++
 748
 749 Execute (TOML frontmatter only works if it's the first thing in the file):
 750   let g:vim_markdown_toml_frontmatter=1
 751   syn off | syn on
 752   AssertNotEqual SyntaxOf('b'), 'tomlString'
 753   unlet g:vim_markdown_toml_frontmatter
 754
 755 # JSON frontmatter
 756
 757 Given markdown;
 758 {
 759   "a": "b"
 760 }
 761
 762 Execute (JSON frontmatter is controlled by the option):
 763   syn off | syn on
 764   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
 765   let g:vim_markdown_json_frontmatter=1
 766   syn off | syn on
 767   AssertEqual SyntaxOf('a'), 'jsonKeyword'
 768   let g:vim_markdown_json_frontmatter=0
 769   syn off | syn on
 770   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
 771
 772 Given markdown;
 773
 774 {
 775   "a": "b"
 776 }
 777
 778 Execute (JSON frontmatter only works if it's the first thing in the file):
 779   let g:vim_markdown_json_frontmatter=1
 780   syn off | syn on
 781   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
 782   unlet g:vim_markdown_json_frontmatter
 783
 784 # Header
 785
 786 Given markdown;
 787 # #a
 788 ccc
 789
 790 ## #b
 791 ddd
 792
 793 Execute (header title starts with #):
 794   AssertEqual SyntaxOf('a'), 'htmlH1'
 795   AssertEqual SyntaxOf('b'), 'htmlH2'
 796
 797 Given markdown;
 798 # h1 space
 799
 800 #h1 nospace
 801
 802 #  h1 2 spaces
 803
 804 # h1 trailing hash #
 805
 806 ## h2 space
 807
 808 ##h2 nospace
 809
 810 ## h2 trailing hash ##
 811
 812 ### h3 space
 813
 814 ###h3 nospace
 815
 816 ### h3 trailing hash ###
 817
 818 #### h4
 819
 820 ##### h5
 821
 822 ###### h6
 823
 824 Execute (atx headers):
 825   AssertEqual SyntaxOf('# h1 space'), 'htmlH1'
 826   AssertEqual SyntaxOf('#h1 nospace'), 'htmlH1'
 827   AssertEqual SyntaxOf('#  h1 2 spaces'), 'htmlH1'
 828   AssertEqual SyntaxOf('# h1 trailing hash #'), 'htmlH1'
 829   AssertEqual SyntaxOf('## h2 space'), 'htmlH2'
 830   AssertEqual SyntaxOf('##h2 nospace'), 'htmlH2'
 831   AssertEqual SyntaxOf('## h2 trailing hash ##'), 'htmlH2'
 832   AssertEqual SyntaxOf('### h3 space'), 'htmlH3'
 833   AssertEqual SyntaxOf('###h3 nospace'), 'htmlH3'
 834   AssertEqual SyntaxOf('### h3 trailing hash ###'), 'htmlH3'
 835   AssertEqual SyntaxOf('#### h4'), 'htmlH4'
 836   AssertEqual SyntaxOf('##### h5'), 'htmlH5'
 837   AssertEqual SyntaxOf('###### h6'), 'htmlH6'
 838
 839 Given markdown;
 840 # h1 before h2
 841
 842 ## h2 between h1s
 843
 844 # h1 after h2
 845
 846 Execute (atx headers relative positions):
 847   AssertEqual SyntaxOf('# h1 before h2'), 'htmlH1'
 848   AssertEqual SyntaxOf('## h2 between h1s'), 'htmlH2'
 849   AssertEqual SyntaxOf('# h1 after h2'), 'htmlH1'
 850
 851 Given markdown;
 852 setex h1
 853 ========
 854
 855 setex h2
 856 --------
 857
 858 setex h1 single punctuation
 859 =
 860
 861 setex h1 punctuation longer than header
 862 ================================
 863
 864 Execute (setex headers):
 865   AssertEqual SyntaxOf('setex h1'), 'htmlH1'
 866   AssertEqual SyntaxOf('^========$'), 'htmlH1'
 867   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
 868   AssertEqual SyntaxOf('--------'), 'htmlH2'
 869   AssertEqual SyntaxOf('setex h1 single punctuation'), 'htmlH1'
 870   AssertEqual SyntaxOf('^=$'), 'htmlH1'
 871   AssertEqual SyntaxOf('setex h1 punctuation longer than header'), 'htmlH1'
 872   AssertEqual SyntaxOf('^================================$'), 'htmlH1'
 873
 874 Given markdown;
 875 - not Setex
 876 - because list
 877
 878 Execute (prevent list vs Setex confusion):
 879   AssertNotEqual SyntaxOf('- not Setex'), 'htmlH2'
 880   AssertNotEqual SyntaxOf('- becuase list'), 'htmlH2'
 881
 882 Given markdown;
 883 setex h1 before atx
 884 ===================
 885
 886 ## atx h2
 887
 888 ### atx h3
 889
 890 # atx h1
 891
 892 setex h2
 893 ------------------
 894
 895 ### atx h3 2
 896
 897 Execute (mixed atx and setex headers):
 898   AssertEqual SyntaxOf('setex h1 before atx'), 'htmlH1'
 899   AssertEqual SyntaxOf('==================='), 'htmlH1'
 900   AssertEqual SyntaxOf('## atx h2'), 'htmlH2'
 901   AssertEqual SyntaxOf('### atx h3'), 'htmlH3'
 902   AssertEqual SyntaxOf('# atx h1'), 'htmlH1'
 903   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
 904   AssertEqual SyntaxOf('------------------'), 'htmlH2'
 905
 906 # List
 907
 908 Given markdown;
 909 - a & b
 910 1. c > d
 911
 912 Execute (& and > are not marked as htmlError in lists):
 913   AssertEqual SyntaxOf('-'), 'mkdListItem'
 914   AssertEqual SyntaxOf('1.'), 'mkdListItem'
 915   AssertNotEqual SyntaxOf('&'), 'htmlError'
 916   AssertNotEqual SyntaxOf('>'), 'htmlError'
 917
 918 Given markdown;
 919 1. a
 920 2. b
 921
 922 Execute (list after line break):
 923   AssertEqual SyntaxOf('1'), 'mkdListItem'
 924   AssertEqual SyntaxOf('2'), 'mkdListItem'
 925
 926 # HTML
 927
 928 Given markdown;
 929 a
 930
 931 <p>b</p>
 932
 933 - <span>c</span>
 934
 935 Execute (HTML tag in text):
 936   AssertEqual SyntaxOf('p'), 'htmlTagName'
 937   AssertEqual SyntaxOf('<p>'), 'htmlTag'
 938   AssertEqual SyntaxOf('</p>'), 'htmlEndTag'
 939   AssertEqual SyntaxOf('span'), 'htmlTagName'
 940   AssertEqual SyntaxOf('<span>'), 'htmlTag'
 941   AssertEqual SyntaxOf('</span>'), 'htmlEndTag'