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 Given markdown;
 324 # [h1link](url)
 325
 326 ## [h2link](url)
 327
 328 ### [h3link](url)
 329
 330 #### [h4link](url)
 331
 332 ##### [h5link](url)
 333
 334 ###### [h6link](url)
 335
 336 [h1link_b](url)
 337 ===============
 338
 339 [h2link_b](url)
 340 ---------------
 341
 342 Execute (link in headers):
 343   AssertEqual SyntaxOf('h1link'), 'mkdLink'
 344   AssertEqual SyntaxOf('h2link'), 'mkdLink'
 345   AssertEqual SyntaxOf('h3link'), 'mkdLink'
 346   AssertEqual SyntaxOf('h4link'), 'mkdLink'
 347   AssertEqual SyntaxOf('h5link'), 'mkdLink'
 348   AssertEqual SyntaxOf('h6link'), 'mkdLink'
 349   AssertEqual SyntaxOf('h1link_b'), 'mkdLink'
 350   AssertEqual SyntaxOf('h2link_b'), 'mkdLink'
 351
 352 Given markdown;
 353 # http://h1link.foo
 354
 355 ## http://h2link.foo
 356
 357 ### http://h3link.foo
 358
 359 #### http://h4link.foo
 360
 361 ##### http://h5link.foo
 362
 363 ###### http://h6link.foo
 364
 365 http://h1link_b.foo
 366 ===================
 367
 368 http://h2link_b.foo
 369 -------------------
 370
 371 Execute (inline url in headers):
 372   AssertEqual SyntaxOf('h1link'), 'mkdInlineURL'
 373   AssertEqual SyntaxOf('h2link'), 'mkdInlineURL'
 374   AssertEqual SyntaxOf('h3link'), 'mkdInlineURL'
 375   AssertEqual SyntaxOf('h4link'), 'mkdInlineURL'
 376   AssertEqual SyntaxOf('h5link'), 'mkdInlineURL'
 377   AssertEqual SyntaxOf('h6link'), 'mkdInlineURL'
 378   AssertEqual SyntaxOf('h1link_b'), 'mkdInlineURL'
 379   AssertEqual SyntaxOf('h2link_b'), 'mkdInlineURL'
 380
 381 Given markdown;
 382 > [a](b)
 383 > http://foo.bar
 384
 385 Execute (link in blockquote):
 386   AssertEqual SyntaxOf('a'), 'mkdLink'
 387   AssertEqual SyntaxOf('foo'), 'mkdInlineURL'
 388
 389 # Code Blocks
 390
 391 Given markdown;
 392 ~~~
 393 code
 394 ~~~
 395
 396 Execute (code blocks can be fenced with tildes):
 397   AssertEqual SyntaxOf('c'), 'mkdCode'
 398
 399 Given markdown;
 400 ~~~~
 401 code
 402 ~~~~~
 403
 404 Execute (code blocks can be fenced with tildes longer than 3):
 405   AssertEqual SyntaxOf('c'), 'mkdCode'
 406
 407 Given markdown;
 408 ````
 409 code
 410 `````
 411
 412 Execute (code blocks can be fenced with backticks longer than 3):
 413   AssertEqual SyntaxOf('c'), 'mkdCode'
 414
 415 Given markdown;
 416 ~~~ruby
 417 code
 418 ~~~
 419
 420 Execute (code blocks can have a language specifier):
 421   AssertEqual SyntaxOf('c'), 'mkdCode'
 422
 423 Given markdown;
 424 ```c++
 425 code
 426 ```
 427
 428 text
 429
 430 Execute (code blocks can be fenced with backticks and a language specifier):
 431   AssertEqual SyntaxOf('code'), 'mkdCode'
 432   AssertNotEqual SyntaxOf('text'), 'mkdCode'
 433
 434 # Indent Code Blocks
 435
 436 Given markdown;
 437 a
 438
 439     b
 440     c
 441
 442 Execute (indent code blocks):
 443   AssertNotEqual SyntaxOf('a'), 'mkdCode'
 444   AssertEqual SyntaxOf('b'), 'mkdCode'
 445   AssertEqual SyntaxOf('c'), 'mkdCode'
 446
 447 Given markdown;
 448 # a
 449
 450 b
 451
 452     c
 453
 454 Execute (indent code blocks after header):
 455   AssertNotEqual SyntaxOf('a'), 'mkdCode'
 456   AssertNotEqual SyntaxOf('b'), 'mkdCode'
 457   AssertEqual SyntaxOf('c'), 'mkdCode'
 458
 459 Given markdown;
 460 -   a
 461
 462     b
 463
 464         c
 465
 466 Execute (indent code blocks after list):
 467   AssertNotEqual SyntaxOf('a'), 'mkdCode'
 468   AssertNotEqual SyntaxOf('b'), 'mkdCode'
 469   AssertEqual SyntaxOf('c'), 'mkdCode'
 470
 471 Given markdown;
 472     a
 473     b
 474
 475 Execute (indent code block at beginning of file):
 476   AssertEqual SyntaxOf('a'), 'mkdCode'
 477   AssertEqual SyntaxOf('b'), 'mkdCode'
 478
 479 Given markdown;
 480 ```c++
 481 #include <iostream>
 482 code
 483 ```
 484
 485 ```ruby
 486 def a
 487 end
 488 ```
 489
 490 Execute (fenced code block syntax with a language specifier):
 491   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
 492   call b:func(0)
 493   AssertEqual SyntaxOf('include'), 'cInclude'
 494   AssertEqual SyntaxOf('code'), 'mkdSnippetCPP'
 495   AssertEqual SyntaxOf('def'), 'rubyDefine'
 496
 497 Given markdown;
 498 ``` c++
 499 #include <iostream>
 500 code
 501 ```
 502
 503 ```  vim
 504 let g:a = 1
 505 ```
 506
 507 ```     ruby
 508 def a
 509 end
 510 ```
 511
 512 ```
 513 ruby
 514 class B
 515 end
 516 ```
 517
 518 Execute (fenced code block syntax with a language specifier after whitespace):
 519   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
 520   call b:func(0)
 521   AssertEqual SyntaxOf('include'), 'cInclude'
 522   AssertEqual SyntaxOf('code'), 'mkdSnippetCPP'
 523   AssertEqual SyntaxOf('g:a'), 'vimVar'
 524   AssertEqual SyntaxOf('def'), 'rubyDefine'
 525   AssertNotEqual SyntaxOf('class'), 'rubyClass'
 526
 527 Given markdown;
 528 ```vim
 529 let g:a = 1
 530 ```
 531
 532 ```viml
 533 let g:b = 1
 534 ```
 535
 536 Execute (fenced code block syntax with alias language specifier):
 537   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
 538   call b:func(0)
 539   AssertEqual SyntaxOf('g:a'), 'vimVar'
 540   AssertEqual SyntaxOf('g:b'), 'vimVar'
 541
 542 Given markdown;
 543 ```csharp
 544 var s = "foo";
 545 ```
 546
 547 Execute (fenced code block languages setting):
 548   let g:vim_markdown_fenced_languages = ['csharp=cs']
 549   source ../ftplugin/markdown.vim
 550   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
 551   call b:func(0)
 552   AssertEqual SyntaxOf('foo'), 'csString'
 553   unlet g:vim_markdown_fenced_languages
 554
 555 Given markdown;
 556 ```vim
 557 let g:a = 1
 558 ```
 559
 560 Execute (fenced code block includes language syntax with reopening same buffer):
 561   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
 562   call b:func(0)
 563   split
 564   quit
 565   edit
 566   set filetype=markdown
 567   execute "normal! i```vim\<cr>let g:a = 1\<cr>```"
 568   call b:func(1)
 569   AssertEqual SyntaxOf('g:a'), 'vimVar'
 570
 571 Given markdown;
 572 ```a+b-
 573 code
 574 ```
 575
 576 Execute (fenced code block syntax with an unknown language specifier):
 577   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
 578   call b:func(0)
 579   AssertEqual SyntaxOf('code'), 'mkdSnippetA_B_'
 580
 581 Given markdown;
 582 ```
 583 =
 584 a
 585 -
 586 ```
 587
 588 Execute (first = or - in fenced code block is not setex headers):
 589   AssertEqual SyntaxOf('='), 'mkdCode'
 590   AssertEqual SyntaxOf('-'), 'mkdCode'
 591
 592 Given markdown;
 593 ``` {style=""}
 594 a
 595 ```
 596
 597 Execute (fenced code block with extended info strings):
 598   AssertEqual SyntaxOf('a'), 'mkdCode'
 599
 600 # Code Blocks in pre and code tag
 601
 602 Given markdown;
 603 <pre>
 604 a
 605 </pre>
 606
 607 Execute (code block in pre tag):
 608   AssertEqual SyntaxOf('a'), 'mkdCode'
 609
 610 Given markdown;
 611 <code>
 612 a
 613 </code>
 614
 615 Execute (code block in code tag):
 616   AssertEqual SyntaxOf('a'), 'mkdCode'
 617
 618 Given markdown;
 619 \<pre\>
 620 a
 621 \</pre\>
 622
 623 Execute (not code block in escaped pre tag):
 624   AssertNotEqual SyntaxOf('a'), 'mkdCode'
 625
 626 Given markdown;
 627 \<code\>
 628 a
 629 \</code\>
 630
 631 Execute (not code block in escaped code tag):
 632   AssertNotEqual SyntaxOf('a'), 'mkdCode'
 633
 634 # Math
 635
 636 Given markdown;
 637 a $x$ b
 638 c $$y$$ d
 639 \$e\$
 640 \$\$f\$\$
 641
 642 Execute (math):
 643   AssertNotEqual SyntaxOf('x')[0:2], 'tex'
 644   AssertNotEqual SyntaxOf('y')[0:2], 'tex'
 645   let g:vim_markdown_math=1
 646   syn off | syn on
 647   AssertNotEqual SyntaxOf('a')[0:2], 'tex'
 648   AssertNotEqual SyntaxOf('b')[0:2], 'tex'
 649   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
 650   AssertNotEqual SyntaxOf('d')[0:2], 'tex'
 651   AssertNotEqual SyntaxOf('e')[0:2], 'tex'
 652   AssertNotEqual SyntaxOf('f')[0:2], 'tex'
 653   AssertEqual SyntaxOf('x')[0:2], 'tex'
 654   AssertEqual SyntaxOf('y')[0:2], 'tex'
 655   let g:vim_markdown_math=0
 656   syn off | syn on
 657   AssertNotEqual SyntaxOf('x')[0:2], 'tex'
 658   AssertNotEqual SyntaxOf('y')[0:2], 'tex'
 659
 660 Given markdown;
 661 a
 662
 663 $
 664 b
 665 $
 666
 667 c
 668
 669 Execute (multiline math):
 670   let g:vim_markdown_math=1
 671   syn off | syn on
 672   AssertNotEqual SyntaxOf('a')[0:2], 'tex'
 673   AssertEqual SyntaxOf('b')[0:2], 'tex'
 674   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
 675
 676 Given markdown;
 677 $ \sqrt{a}{b} $
 678 $$ \frac{a}{b} $$
 679
 680 Execute (math tex highlighting):
 681   let g:vim_markdown_math=0
 682   syn off | syn on
 683   AssertNotEqual SyntaxOf('sqrt'), 'texStatement'
 684   AssertNotEqual SyntaxOf('frac'), 'texStatement'
 685   let g:vim_markdown_math=1
 686   syn off | syn on
 687   AssertEqual SyntaxOf('sqrt'), 'texStatement'
 688   AssertEqual SyntaxOf('frac'), 'texStatement'
 689
 690 Given markdown;
 691 $a b[$ c
 692
 693 Execute (math ends with $):
 694   let g:vim_markdown_math=1
 695   syn off | syn on
 696   AssertEqual SyntaxOf('a')[0:2], 'tex'
 697   AssertEqual SyntaxOf('b')[0:2], 'tex'
 698   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
 699
 700 Given markdown;
 701 $$a b[$$ c
 702
 703 Execute (math ends with $$):
 704   let g:vim_markdown_math=1
 705   syn off | syn on
 706   AssertEqual SyntaxOf('a')[0:2], 'tex'
 707   AssertEqual SyntaxOf('b')[0:2], 'tex'
 708   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
 709
 710 Given markdown;
 711 $(0 \le 1)$
 712
 713 Execute (math conceal in $):
 714   if has('conceal')
 715     setlocal conceallevel=2
 716     let g:vim_markdown_math=1
 717     syn off | syn on
 718     AssertEqual synconcealed(1, 1)[0], 1, '$'
 719     AssertEqual synconcealed(1, 2)[0], 0
 720     AssertEqual synconcealed(1, 3)[0], 0
 721     AssertEqual synconcealed(1, 4)[0], 0
 722     AssertEqual synconcealed(1, 5)[0], 1, '\le'
 723     AssertEqual synconcealed(1, 6)[0], 1
 724     AssertEqual synconcealed(1, 7)[0], 1
 725     AssertEqual synconcealed(1, 8)[0], 0
 726     AssertEqual synconcealed(1, 9)[0], 0
 727     AssertEqual synconcealed(1, 10)[0], 0
 728     AssertEqual synconcealed(1, 11)[0], 1, '$'
 729     setlocal conceallevel=0
 730   endif
 731
 732 Given markdown;
 733 $$
 734 \omega
 735 0 \le 1
 736 $$
 737
 738 Execute (math conceal in $$):
 739   if has('conceal')
 740     setlocal conceallevel=2
 741     let g:vim_markdown_math=1
 742     syn off | syn on
 743     AssertEqual synconcealed(1, 1)[0], 1, '$$'
 744     AssertEqual synconcealed(2, 1)[0], 1, '\omega'
 745     AssertEqual synconcealed(3, 1)[0], 0, '0'
 746     AssertEqual synconcealed(3, 3)[0], 1, '\le'
 747     AssertEqual synconcealed(3, 7)[0], 0, '1'
 748     AssertEqual synconcealed(4, 1)[0], 1, '$$'
 749     setlocal conceallevel=0
 750   endif
 751
 752 # YAML frontmatter
 753
 754 Given markdown;
 755 ---
 756 a: b
 757 ---
 758
 759 Execute (YAML frontmatter is controlled by the option):
 760   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
 761   let g:vim_markdown_frontmatter=1
 762   syn off | syn on
 763   AssertEqual SyntaxOf('a')[0:3], 'yaml'
 764   let g:vim_markdown_frontmatter=0
 765   syn off | syn on
 766   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
 767
 768 Given markdown;
 769
 770 ---
 771 a: b
 772 ---
 773
 774 Execute (YAML frontmatter only works if it's the first thing in the file):
 775   let g:vim_markdown_frontmatter=1
 776   syn off | syn on
 777   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
 778
 779 Given markdown;
 780 ---
 781 a: b
 782 ---
 783
 784 ---
 785
 786 Execute (rules are not mistaken by YAML frontmatter delimiters):
 787   let g:vim_markdown_frontmatter=1
 788   syn off | syn on
 789   AssertEqual SyntaxAt(5, 1), 'mkdRule'
 790   unlet g:vim_markdown_frontmatter
 791
 792 # TOML frontmatter
 793
 794 Given markdown;
 795 +++
 796 a = "b"
 797 +++
 798
 799 Execute (TOML frontmatter is controlled by the option):
 800   syn off | syn on
 801   AssertNotEqual SyntaxOf('b'), 'tomlString'
 802   let g:vim_markdown_toml_frontmatter=1
 803   syn off | syn on
 804   AssertEqual SyntaxOf('b'), 'tomlString'
 805   let g:vim_markdown_toml_frontmatter=0
 806   syn off | syn on
 807   AssertNotEqual SyntaxOf('b'), 'tomlString'
 808
 809 Given markdown;
 810
 811 +++
 812 a = "b"
 813 +++
 814
 815 Execute (TOML frontmatter only works if it's the first thing in the file):
 816   let g:vim_markdown_toml_frontmatter=1
 817   syn off | syn on
 818   AssertNotEqual SyntaxOf('b'), 'tomlString'
 819   unlet g:vim_markdown_toml_frontmatter
 820
 821 # JSON frontmatter
 822
 823 Given markdown;
 824 {
 825   "a": "b"
 826 }
 827
 828 Execute (JSON frontmatter is controlled by the option):
 829   syn off | syn on
 830   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
 831   let g:vim_markdown_json_frontmatter=1
 832   syn off | syn on
 833   AssertEqual SyntaxOf('a'), 'jsonKeyword'
 834   let g:vim_markdown_json_frontmatter=0
 835   syn off | syn on
 836   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
 837
 838 Given markdown;
 839
 840 {
 841   "a": "b"
 842 }
 843
 844 Execute (JSON frontmatter only works if it's the first thing in the file):
 845   let g:vim_markdown_json_frontmatter=1
 846   syn off | syn on
 847   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
 848   unlet g:vim_markdown_json_frontmatter
 849
 850 # Header
 851
 852 Given markdown;
 853 # #a
 854 ccc
 855
 856 ## #b
 857 ddd
 858
 859 Execute (header title starts with #):
 860   AssertEqual SyntaxOf('a'), 'htmlH1'
 861   AssertEqual SyntaxOf('b'), 'htmlH2'
 862
 863 Given markdown;
 864 # h1 space
 865
 866 #h1 nospace
 867
 868 #  h1 2 spaces
 869
 870 # h1 trailing hash #
 871
 872 ## h2 space
 873
 874 ##h2 nospace
 875
 876 ## h2 trailing hash ##
 877
 878 ### h3 space
 879
 880 ###h3 nospace
 881
 882 ### h3 trailing hash ###
 883
 884 #### h4
 885
 886 ##### h5
 887
 888 ###### h6
 889
 890 Execute (atx headers):
 891   AssertEqual SyntaxOf('# h1 space'), 'htmlH1'
 892   AssertEqual SyntaxOf('#h1 nospace'), 'htmlH1'
 893   AssertEqual SyntaxOf('#  h1 2 spaces'), 'htmlH1'
 894   AssertEqual SyntaxOf('# h1 trailing hash #'), 'htmlH1'
 895   AssertEqual SyntaxOf('## h2 space'), 'htmlH2'
 896   AssertEqual SyntaxOf('##h2 nospace'), 'htmlH2'
 897   AssertEqual SyntaxOf('## h2 trailing hash ##'), 'htmlH2'
 898   AssertEqual SyntaxOf('### h3 space'), 'htmlH3'
 899   AssertEqual SyntaxOf('###h3 nospace'), 'htmlH3'
 900   AssertEqual SyntaxOf('### h3 trailing hash ###'), 'htmlH3'
 901   AssertEqual SyntaxOf('#### h4'), 'htmlH4'
 902   AssertEqual SyntaxOf('##### h5'), 'htmlH5'
 903   AssertEqual SyntaxOf('###### h6'), 'htmlH6'
 904
 905 Given markdown;
 906 # h1 before h2
 907
 908 ## h2 between h1s
 909
 910 # h1 after h2
 911
 912 Execute (atx headers relative positions):
 913   AssertEqual SyntaxOf('# h1 before h2'), 'htmlH1'
 914   AssertEqual SyntaxOf('## h2 between h1s'), 'htmlH2'
 915   AssertEqual SyntaxOf('# h1 after h2'), 'htmlH1'
 916
 917 Given markdown;
 918 setex h1
 919 ========
 920
 921 setex h2
 922 --------
 923
 924 setex h1 single punctuation
 925 =
 926
 927 setex h1 punctuation longer than header
 928 ================================
 929
 930 Execute (setex headers):
 931   AssertEqual SyntaxOf('setex h1'), 'htmlH1'
 932   AssertEqual SyntaxOf('^========$'), 'htmlH1'
 933   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
 934   AssertEqual SyntaxOf('--------'), 'htmlH2'
 935   AssertEqual SyntaxOf('setex h1 single punctuation'), 'htmlH1'
 936   AssertEqual SyntaxOf('^=$'), 'htmlH1'
 937   AssertEqual SyntaxOf('setex h1 punctuation longer than header'), 'htmlH1'
 938   AssertEqual SyntaxOf('^================================$'), 'htmlH1'
 939
 940 Given markdown;
 941 - not Setex
 942 - because list
 943
 944 Execute (prevent list vs Setex confusion):
 945   AssertNotEqual SyntaxOf('- not Setex'), 'htmlH2'
 946   AssertNotEqual SyntaxOf('- becuase list'), 'htmlH2'
 947
 948 Given markdown;
 949 setex h1 before atx
 950 ===================
 951
 952 ## atx h2
 953
 954 ### atx h3
 955
 956 # atx h1
 957
 958 setex h2
 959 ------------------
 960
 961 ### atx h3 2
 962
 963 Execute (mixed atx and setex headers):
 964   AssertEqual SyntaxOf('setex h1 before atx'), 'htmlH1'
 965   AssertEqual SyntaxOf('==================='), 'htmlH1'
 966   AssertEqual SyntaxOf('## atx h2'), 'htmlH2'
 967   AssertEqual SyntaxOf('### atx h3'), 'htmlH3'
 968   AssertEqual SyntaxOf('# atx h1'), 'htmlH1'
 969   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
 970   AssertEqual SyntaxOf('------------------'), 'htmlH2'
 971
 972 # List
 973
 974 Given markdown;
 975 - a & b
 976 1. c > d
 977
 978 Execute (& and > are not marked as htmlError in lists):
 979   AssertEqual SyntaxOf('-'), 'mkdListItem'
 980   AssertEqual SyntaxOf('1.'), 'mkdListItem'
 981   AssertNotEqual SyntaxOf('&'), 'htmlError'
 982   AssertNotEqual SyntaxOf('>'), 'htmlError'
 983
 984 Given markdown;
 985 1. a
 986 2. b
 987
 988 Execute (list after line break):
 989   AssertEqual SyntaxOf('1'), 'mkdListItem'
 990   AssertEqual SyntaxOf('2'), 'mkdListItem'
 991
 992 # HTML
 993
 994 Given markdown;
 995 a
 996
 997 <p>b</p>
 998
 999 - <span>c</span>
1000
1001 Execute (HTML tag in text):
1002   AssertEqual SyntaxOf('p'), 'htmlTagName'
1003   AssertEqual SyntaxOf('<p>'), 'htmlTag'
1004   AssertEqual SyntaxOf('</p>'), 'htmlEndTag'
1005   AssertEqual SyntaxOf('span'), 'htmlTagName'
1006   AssertEqual SyntaxOf('<span>'), 'htmlTag'
1007   AssertEqual SyntaxOf('</span>'), 'htmlEndTag'