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 Given markdown;
 171 _a_
 172
 173 Execute (conceal italic):
 174   if has('conceal')
 175     setlocal conceallevel=2
 176     AssertEqual synconcealed(1, 1)[0], 1
 177     AssertEqual synconcealed(1, 2)[0], 0
 178     AssertEqual synconcealed(1, 3)[0], 1
 179     setlocal conceallevel=0
 180   endif
 181
 182 Execute (disable conceal):
 183   if has('conceal')
 184     let g:vim_markdown_conceal=0
 185     syn off | syn on
 186     setlocal conceallevel=2
 187     AssertEqual synconcealed(1, 1)[0], 0
 188     AssertEqual synconcealed(1, 2)[0], 0
 189     AssertEqual synconcealed(1, 3)[0], 0
 190
 191     let g:vim_markdown_conceal=1
 192     syn off | syn on
 193     AssertEqual synconcealed(1, 1)[0], 1
 194     AssertEqual synconcealed(1, 2)[0], 0
 195     AssertEqual synconcealed(1, 3)[0], 1
 196
 197     setlocal conceallevel=0
 198     unlet g:vim_markdown_conceal
 199     syn off | syn on
 200   endif
 201
 202 Given markdown;
 203 *a*
 204
 205 Execute (conceal italic):
 206   if has('conceal')
 207     setlocal conceallevel=2
 208     AssertEqual synconcealed(1, 1)[0], 1
 209     AssertEqual synconcealed(1, 2)[0], 0
 210     AssertEqual synconcealed(1, 3)[0], 1
 211     setlocal conceallevel=0
 212   endif
 213
 214 Execute (disable conceal):
 215   if has('conceal')
 216     let g:vim_markdown_conceal=0
 217     syn off | syn on
 218     setlocal conceallevel=2
 219     AssertEqual synconcealed(1, 1)[0], 0
 220     AssertEqual synconcealed(1, 2)[0], 0
 221     AssertEqual synconcealed(1, 3)[0], 0
 222
 223     let g:vim_markdown_conceal=1
 224     syn off | syn on
 225     AssertEqual synconcealed(1, 1)[0], 1
 226     AssertEqual synconcealed(1, 2)[0], 0
 227     AssertEqual synconcealed(1, 3)[0], 1
 228
 229     setlocal conceallevel=0
 230     unlet g:vim_markdown_conceal
 231     syn off | syn on
 232   endif
 233
 234 Given markdown;
 235 __a__
 236
 237 Execute (conceal bold):
 238   if has('conceal')
 239     setlocal conceallevel=2
 240     AssertEqual synconcealed(1, 1)[0], 1
 241     AssertEqual synconcealed(1, 2)[0], 1
 242     AssertEqual synconcealed(1, 3)[0], 0
 243     AssertEqual synconcealed(1, 4)[0], 1
 244     AssertEqual synconcealed(1, 5)[0], 1
 245     setlocal conceallevel=0
 246   endif
 247
 248 Execute (disable conceal):
 249   if has('conceal')
 250     let g:vim_markdown_conceal=0
 251     syn off | syn on
 252     setlocal conceallevel=2
 253     AssertEqual synconcealed(1, 1)[0], 0
 254     AssertEqual synconcealed(1, 2)[0], 0
 255     AssertEqual synconcealed(1, 3)[0], 0
 256     AssertEqual synconcealed(1, 4)[0], 0
 257     AssertEqual synconcealed(1, 5)[0], 0
 258
 259     let g:vim_markdown_conceal=1
 260     syn off | syn on
 261     AssertEqual synconcealed(1, 1)[0], 1
 262     AssertEqual synconcealed(1, 2)[0], 1
 263     AssertEqual synconcealed(1, 3)[0], 0
 264     AssertEqual synconcealed(1, 4)[0], 1
 265     AssertEqual synconcealed(1, 5)[0], 1
 266
 267     setlocal conceallevel=0
 268     unlet g:vim_markdown_conceal
 269     syn off | syn on
 270   endif
 271
 272 Given markdown;
 273 **a**
 274
 275 Execute (conceal bold):
 276   if has('conceal')
 277     setlocal conceallevel=2
 278     AssertEqual synconcealed(1, 1)[0], 1
 279     AssertEqual synconcealed(1, 2)[0], 1
 280     AssertEqual synconcealed(1, 3)[0], 0
 281     AssertEqual synconcealed(1, 4)[0], 1
 282     AssertEqual synconcealed(1, 5)[0], 1
 283     setlocal conceallevel=0
 284   endif
 285
 286 Execute (disable conceal):
 287   if has('conceal')
 288     let g:vim_markdown_conceal=0
 289     syn off | syn on
 290     setlocal conceallevel=2
 291     AssertEqual synconcealed(1, 1)[0], 0
 292     AssertEqual synconcealed(1, 2)[0], 0
 293     AssertEqual synconcealed(1, 3)[0], 0
 294     AssertEqual synconcealed(1, 4)[0], 0
 295     AssertEqual synconcealed(1, 5)[0], 0
 296
 297     let g:vim_markdown_conceal=1
 298     syn off | syn on
 299     AssertEqual synconcealed(1, 1)[0], 1
 300     AssertEqual synconcealed(1, 2)[0], 1
 301     AssertEqual synconcealed(1, 3)[0], 0
 302     AssertEqual synconcealed(1, 4)[0], 1
 303     AssertEqual synconcealed(1, 5)[0], 1
 304
 305     setlocal conceallevel=0
 306     unlet g:vim_markdown_conceal
 307     syn off | syn on
 308   endif
 309
 310 Given markdown;
 311 ___a___
 312
 313 Execute (conceal italic bold):
 314   if has('conceal')
 315     setlocal conceallevel=2
 316     AssertEqual synconcealed(1, 1)[0], 1
 317     AssertEqual synconcealed(1, 2)[0], 1
 318     AssertEqual synconcealed(1, 3)[0], 1
 319     AssertEqual synconcealed(1, 4)[0], 0
 320     AssertEqual synconcealed(1, 5)[0], 1
 321     AssertEqual synconcealed(1, 6)[0], 1
 322     AssertEqual synconcealed(1, 7)[0], 1
 323     setlocal conceallevel=0
 324   endif
 325
 326 Execute (disable conceal):
 327   if has('conceal')
 328     let g:vim_markdown_conceal=0
 329     syn off | syn on
 330     setlocal conceallevel=2
 331     AssertEqual synconcealed(1, 1)[0], 0
 332     AssertEqual synconcealed(1, 2)[0], 0
 333     AssertEqual synconcealed(1, 3)[0], 0
 334     AssertEqual synconcealed(1, 4)[0], 0
 335     AssertEqual synconcealed(1, 5)[0], 0
 336     AssertEqual synconcealed(1, 6)[0], 0
 337     AssertEqual synconcealed(1, 7)[0], 0
 338
 339     let g:vim_markdown_conceal=1
 340     syn off | syn on
 341     AssertEqual synconcealed(1, 1)[0], 1
 342     AssertEqual synconcealed(1, 2)[0], 1
 343     AssertEqual synconcealed(1, 3)[0], 1
 344     AssertEqual synconcealed(1, 4)[0], 0
 345     AssertEqual synconcealed(1, 5)[0], 1
 346     AssertEqual synconcealed(1, 6)[0], 1
 347     AssertEqual synconcealed(1, 7)[0], 1
 348
 349     setlocal conceallevel=0
 350     unlet g:vim_markdown_conceal
 351     syn off | syn on
 352   endif
 353
 354 Given markdown;
 355 ***a***
 356
 357 Execute (conceal italic bold):
 358   if has('conceal')
 359     setlocal conceallevel=2
 360     AssertEqual synconcealed(1, 1)[0], 1
 361     AssertEqual synconcealed(1, 2)[0], 1
 362     AssertEqual synconcealed(1, 3)[0], 1
 363     AssertEqual synconcealed(1, 4)[0], 0
 364     AssertEqual synconcealed(1, 5)[0], 1
 365     AssertEqual synconcealed(1, 6)[0], 1
 366     AssertEqual synconcealed(1, 7)[0], 1
 367     setlocal conceallevel=0
 368   endif
 369
 370 Execute (disable conceal):
 371   if has('conceal')
 372     let g:vim_markdown_conceal=0
 373     syn off | syn on
 374     setlocal conceallevel=2
 375     AssertEqual synconcealed(1, 1)[0], 0
 376     AssertEqual synconcealed(1, 2)[0], 0
 377     AssertEqual synconcealed(1, 3)[0], 0
 378     AssertEqual synconcealed(1, 4)[0], 0
 379     AssertEqual synconcealed(1, 5)[0], 0
 380     AssertEqual synconcealed(1, 6)[0], 0
 381     AssertEqual synconcealed(1, 7)[0], 0
 382
 383     let g:vim_markdown_conceal=1
 384     syn off | syn on
 385     AssertEqual synconcealed(1, 1)[0], 1
 386     AssertEqual synconcealed(1, 2)[0], 1
 387     AssertEqual synconcealed(1, 3)[0], 1
 388     AssertEqual synconcealed(1, 4)[0], 0
 389     AssertEqual synconcealed(1, 5)[0], 1
 390     AssertEqual synconcealed(1, 6)[0], 1
 391     AssertEqual synconcealed(1, 7)[0], 1
 392
 393     setlocal conceallevel=0
 394     unlet g:vim_markdown_conceal
 395     syn off | syn on
 396   endif
 397
 398 # Links
 399
 400 Given markdown;
 401 [a](b)
 402
 403 Execute (link with title):
 404   AssertEqual SyntaxOf('a'), 'mkdLink'
 405   AssertEqual SyntaxOf('b'), 'mkdURL'
 406
 407 Given markdown;
 408 [a
 409 b](c)
 410
 411 Execute (link text with newline):
 412   AssertEqual SyntaxOf('a'), 'mkdLink'
 413   AssertEqual SyntaxOf('b'), 'mkdLink'
 414   AssertEqual SyntaxOf('c'), 'mkdURL'
 415
 416 Given markdown;
 417 (a)
 418
 419 (b)
 420
 421 Execute (parenthesis not in link):
 422   AssertNotEqual SyntaxOf('a'), 'mkdURL'
 423   AssertNotEqual SyntaxOf('b'), 'mkdURL'
 424
 425 Given markdown;
 426 [a](b) c [d](e)
 427
 428 Execute (multiple links on a line):
 429   AssertNotEqual SyntaxOf('c'), 'mkdLink'
 430   AssertNotEqual SyntaxOf('c'), 'mkdURL'
 431
 432 Given markdown;
 433 [a] (b)
 434
 435 Execute (space is not allowed between link text and parenthesis):
 436   AssertNotEqual SyntaxOf('a'), 'mkdLink'
 437   AssertNotEqual SyntaxOf('b'), 'mkdURL'
 438
 439 Given markdown;
 440 [a](b)
 441
 442 Execute (conceal link):
 443   if has('conceal')
 444     setlocal conceallevel=2
 445     AssertEqual synconcealed(1, 1)[0], 1
 446     AssertEqual synconcealed(1, 2)[0], 0
 447     AssertEqual synconcealed(1, 3)[0], 1
 448     AssertEqual synconcealed(1, 4)[0], 1
 449     AssertEqual synconcealed(1, 4)[0], 1
 450     AssertEqual synconcealed(1, 5)[0], 1
 451     AssertEqual synconcealed(1, 6)[0], 1
 452     setlocal conceallevel=0
 453   endif
 454
 455 Execute (disable conceal):
 456   if has('conceal')
 457     let g:vim_markdown_conceal=0
 458     syn off | syn on
 459     setlocal conceallevel=2
 460     AssertEqual synconcealed(1, 1)[0], 0
 461     AssertEqual synconcealed(1, 2)[0], 0
 462     AssertEqual synconcealed(1, 3)[0], 0
 463     AssertEqual synconcealed(1, 4)[0], 0
 464     AssertEqual synconcealed(1, 4)[0], 0
 465     AssertEqual synconcealed(1, 5)[0], 0
 466     AssertEqual synconcealed(1, 6)[0], 0
 467
 468     let g:vim_markdown_conceal=1
 469     syn off | syn on
 470     AssertEqual synconcealed(1, 1)[0], 1
 471     AssertEqual synconcealed(1, 2)[0], 0
 472     AssertEqual synconcealed(1, 3)[0], 1
 473     AssertEqual synconcealed(1, 4)[0], 1
 474     AssertEqual synconcealed(1, 4)[0], 1
 475     AssertEqual synconcealed(1, 5)[0], 1
 476     AssertEqual synconcealed(1, 6)[0], 1
 477
 478     setlocal conceallevel=0
 479     unlet g:vim_markdown_conceal
 480     syn off | syn on
 481   endif
 482
 483 # Autolinks
 484
 485 Given markdown;
 486 a <http://b> c
 487
 488 Execute (autolink):
 489   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
 490   AssertEqual SyntaxOf('<'), 'mkdDelimiter'
 491   AssertEqual SyntaxOf('b'), 'mkdInlineURL'
 492   AssertEqual SyntaxOf('>'), 'mkdDelimiter'
 493   AssertNotEqual SyntaxOf('c'), 'mkdInlineURL'
 494
 495 Given markdown;
 496 http://12monkeys.foo
 497
 498 Execute (autolink with domain starting with a number):
 499   AssertEqual SyntaxOf('12monkeys'), 'mkdInlineURL'
 500
 501 Given markdown;
 502 <HtTp://a>
 503
 504 Execute (autolink with scheme case is insensitive):
 505   AssertEqual SyntaxOf('a'), 'mkdInlineURL'
 506
 507 Given markdown;
 508 <a>
 509
 510 Execute (autolink without scheme is not a link):
 511   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
 512
 513 Given markdown;
 514 < http://a >
 515 <http://b c>
 516 <http://d
 517 e>
 518
 519 Execute (autolink with space is not a link):
 520   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
 521   AssertNotEqual SyntaxOf('b'), 'mkdInlineURL'
 522   AssertNotEqual SyntaxOf('c'), 'mkdInlineURL'
 523   AssertNotEqual SyntaxOf('d'), 'mkdInlineURL'
 524   AssertNotEqual SyntaxOf('e'), 'mkdInlineURL'
 525
 526 Given markdown;
 527 \<http://a>
 528
 529 Execute (autolinks can be backslash escaped):
 530   AssertNotEqual SyntaxOf('<'), 'mkdDelimiter'
 531
 532 Given markdown;
 533 a (http://b.bb) c
 534
 535 Execute (autolink in parenthesis):
 536   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
 537   AssertEqual SyntaxOf('('), 'mkdDelimiter'
 538   AssertEqual SyntaxOf('b'), 'mkdInlineURL'
 539   AssertEqual SyntaxOf(')'), 'mkdDelimiter'
 540   AssertNotEqual SyntaxOf('c'), 'mkdInlineURL'
 541
 542 Given markdown;
 543 [![a](http://b)](http://c)
 544
 545 Execute (autolink in link text):
 546   AssertEqual SyntaxOf('!'), 'mkdDelimiter'
 547   AssertEqual SyntaxOf('a'), 'mkdLink'
 548   AssertEqual SyntaxOf('b'), 'mkdURL'
 549   AssertEqual SyntaxOf('c'), 'mkdURL'
 550
 551 Given markdown;
 552 # [h1link](url)
 553
 554 ## [h2link](url)
 555
 556 ### [h3link](url)
 557
 558 #### [h4link](url)
 559
 560 ##### [h5link](url)
 561
 562 ###### [h6link](url)
 563
 564 [h1link_b](url)
 565 ===============
 566
 567 [h2link_b](url)
 568 ---------------
 569
 570 Execute (link in headers):
 571   AssertEqual SyntaxOf('h1link'), 'mkdLink'
 572   AssertEqual SyntaxOf('h2link'), 'mkdLink'
 573   AssertEqual SyntaxOf('h3link'), 'mkdLink'
 574   AssertEqual SyntaxOf('h4link'), 'mkdLink'
 575   AssertEqual SyntaxOf('h5link'), 'mkdLink'
 576   AssertEqual SyntaxOf('h6link'), 'mkdLink'
 577   AssertEqual SyntaxOf('h1link_b'), 'mkdLink'
 578   AssertEqual SyntaxOf('h2link_b'), 'mkdLink'
 579
 580 Given markdown;
 581 # http://h1link.foo
 582
 583 ## http://h2link.foo
 584
 585 ### http://h3link.foo
 586
 587 #### http://h4link.foo
 588
 589 ##### http://h5link.foo
 590
 591 ###### http://h6link.foo
 592
 593 http://h1link_b.foo
 594 ===================
 595
 596 http://h2link_b.foo
 597 -------------------
 598
 599 Execute (inline url in headers):
 600   AssertEqual SyntaxOf('h1link'), 'mkdInlineURL'
 601   AssertEqual SyntaxOf('h2link'), 'mkdInlineURL'
 602   AssertEqual SyntaxOf('h3link'), 'mkdInlineURL'
 603   AssertEqual SyntaxOf('h4link'), 'mkdInlineURL'
 604   AssertEqual SyntaxOf('h5link'), 'mkdInlineURL'
 605   AssertEqual SyntaxOf('h6link'), 'mkdInlineURL'
 606   AssertEqual SyntaxOf('h1link_b'), 'mkdInlineURL'
 607   AssertEqual SyntaxOf('h2link_b'), 'mkdInlineURL'
 608
 609 Given markdown;
 610 > [a](b)
 611 > http://foo.bar
 612
 613 Execute (link in blockquote):
 614   AssertEqual SyntaxOf('a'), 'mkdLink'
 615   AssertEqual SyntaxOf('foo'), 'mkdInlineURL'
 616
 617 # Code Blocks
 618
 619 Given markdown;
 620 ~~~
 621 code
 622 ~~~
 623
 624 Execute (code blocks can be fenced with tildes):
 625   AssertEqual SyntaxOf('c'), 'mkdCode'
 626
 627 Given markdown;
 628 ~~~~
 629 code
 630 ~~~~~
 631
 632 Execute (code blocks can be fenced with tildes longer than 3):
 633   AssertEqual SyntaxOf('c'), 'mkdCode'
 634
 635 Given markdown;
 636 ````
 637 code
 638 `````
 639
 640 Execute (code blocks can be fenced with backticks longer than 3):
 641   AssertEqual SyntaxOf('c'), 'mkdCode'
 642
 643 Given markdown;
 644 ~~~ruby
 645 code
 646 ~~~
 647
 648 Execute (code blocks can have a language specifier):
 649   AssertEqual SyntaxOf('c'), 'mkdCode'
 650
 651 Given markdown;
 652 ```c++
 653 code
 654 ```
 655
 656 text
 657
 658 Execute (code blocks can be fenced with backticks and a language specifier):
 659   AssertEqual SyntaxOf('code'), 'mkdCode'
 660   AssertNotEqual SyntaxOf('text'), 'mkdCode'
 661
 662 # Indent Code Blocks
 663
 664 Given markdown;
 665 a
 666
 667     b
 668     c
 669
 670 Execute (indent code blocks):
 671   AssertNotEqual SyntaxOf('a'), 'mkdCode'
 672   AssertEqual SyntaxOf('b'), 'mkdCode'
 673   AssertEqual SyntaxOf('c'), 'mkdCode'
 674
 675 Given markdown;
 676 # a
 677
 678 b
 679
 680     c
 681
 682 Execute (indent code blocks after header):
 683   AssertNotEqual SyntaxOf('a'), 'mkdCode'
 684   AssertNotEqual SyntaxOf('b'), 'mkdCode'
 685   AssertEqual SyntaxOf('c'), 'mkdCode'
 686
 687 Given markdown;
 688 -   a
 689
 690     b
 691
 692         c
 693
 694 Execute (indent code blocks after list):
 695   AssertNotEqual SyntaxOf('a'), 'mkdCode'
 696   AssertNotEqual SyntaxOf('b'), 'mkdCode'
 697   AssertEqual SyntaxOf('c'), 'mkdCode'
 698
 699 Given markdown;
 700     a
 701     b
 702
 703 Execute (indent code block at beginning of file):
 704   AssertEqual SyntaxOf('a'), 'mkdCode'
 705   AssertEqual SyntaxOf('b'), 'mkdCode'
 706
 707 Given markdown;
 708 ```c++
 709 #include <iostream>
 710 code
 711 ```
 712
 713 ```ruby
 714 def a
 715 end
 716 ```
 717
 718 Execute (fenced code block syntax with a language specifier):
 719   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
 720   call b:func(0)
 721   AssertEqual SyntaxOf('include'), 'cInclude'
 722   AssertEqual SyntaxOf('code'), 'mkdSnippetCPP'
 723   AssertEqual SyntaxOf('def'), 'rubyDefine'
 724
 725 Given markdown;
 726 ``` c++
 727 #include <iostream>
 728 code
 729 ```
 730
 731 ```  vim
 732 let g:a = 1
 733 ```
 734
 735 ```     ruby
 736 def a
 737 end
 738 ```
 739
 740 ```
 741 ruby
 742 class B
 743 end
 744 ```
 745
 746 Execute (fenced code block syntax with a language specifier after whitespace):
 747   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
 748   call b:func(0)
 749   AssertEqual SyntaxOf('include'), 'cInclude'
 750   AssertEqual SyntaxOf('code'), 'mkdSnippetCPP'
 751   AssertEqual SyntaxOf('g:a'), 'vimVar'
 752   AssertEqual SyntaxOf('def'), 'rubyDefine'
 753   AssertNotEqual SyntaxOf('class'), 'rubyClass'
 754
 755 Given markdown;
 756 ```vim
 757 let g:a = 1
 758 ```
 759
 760 ```viml
 761 let g:b = 1
 762 ```
 763
 764 Execute (fenced code block syntax with alias language specifier):
 765   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
 766   call b:func(0)
 767   AssertEqual SyntaxOf('g:a'), 'vimVar'
 768   AssertEqual SyntaxOf('g:b'), 'vimVar'
 769
 770 Given markdown;
 771 ```csharp
 772 var s = "foo";
 773 ```
 774
 775 Execute (fenced code block languages setting):
 776   let g:vim_markdown_fenced_languages = ['csharp=cs']
 777   source ../ftplugin/markdown.vim
 778   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
 779   call b:func(0)
 780   AssertEqual SyntaxOf('foo'), 'csString'
 781   unlet g:vim_markdown_fenced_languages
 782
 783 Given markdown;
 784 ```vim
 785 let g:a = 1
 786 ```
 787
 788 Execute (fenced code block includes language syntax with reopening same buffer):
 789   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
 790   call b:func(0)
 791   split
 792   quit
 793   edit
 794   set filetype=markdown
 795   execute "normal! i```vim\<cr>let g:a = 1\<cr>```"
 796   call b:func(1)
 797   AssertEqual SyntaxOf('g:a'), 'vimVar'
 798
 799 Given markdown;
 800 ```a+b-
 801 code
 802 ```
 803
 804 Execute (fenced code block syntax with an unknown language specifier):
 805   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
 806   call b:func(0)
 807   AssertEqual SyntaxOf('code'), 'mkdSnippetA_B_'
 808
 809 Given markdown;
 810 ```
 811 =
 812 a
 813 -
 814 ```
 815
 816 Execute (first = or - in fenced code block is not setex headers):
 817   AssertEqual SyntaxOf('='), 'mkdCode'
 818   AssertEqual SyntaxOf('-'), 'mkdCode'
 819
 820 Given markdown;
 821 ``` {style=""}
 822 a
 823 ```
 824
 825 Execute (fenced code block with extended info strings):
 826   AssertEqual SyntaxOf('a'), 'mkdCode'
 827
 828 # Code Blocks in pre and code tag
 829
 830 Given markdown;
 831 <pre>
 832 a
 833 </pre>
 834
 835 Execute (code block in pre tag):
 836   AssertEqual SyntaxOf('a'), 'mkdCode'
 837
 838 Given markdown;
 839 <code>
 840 a
 841 </code>
 842
 843 Execute (code block in code tag):
 844   AssertEqual SyntaxOf('a'), 'mkdCode'
 845
 846 Given markdown;
 847 \<pre\>
 848 a
 849 \</pre\>
 850
 851 Execute (not code block in escaped pre tag):
 852   AssertNotEqual SyntaxOf('a'), 'mkdCode'
 853
 854 Given markdown;
 855 \<code\>
 856 a
 857 \</code\>
 858
 859 Execute (not code block in escaped code tag):
 860   AssertNotEqual SyntaxOf('a'), 'mkdCode'
 861
 862 # Math
 863
 864 Given markdown;
 865 a $x$ b
 866 c $$y$$ d
 867 \$e\$
 868 \$\$f\$\$
 869
 870 Execute (math):
 871   AssertNotEqual SyntaxOf('x')[0:2], 'tex'
 872   AssertNotEqual SyntaxOf('y')[0:2], 'tex'
 873   let g:vim_markdown_math=1
 874   syn off | syn on
 875   AssertNotEqual SyntaxOf('a')[0:2], 'tex'
 876   AssertNotEqual SyntaxOf('b')[0:2], 'tex'
 877   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
 878   AssertNotEqual SyntaxOf('d')[0:2], 'tex'
 879   AssertNotEqual SyntaxOf('e')[0:2], 'tex'
 880   AssertNotEqual SyntaxOf('f')[0:2], 'tex'
 881   AssertEqual SyntaxOf('x')[0:2], 'tex'
 882   AssertEqual SyntaxOf('y')[0:2], 'tex'
 883   let g:vim_markdown_math=0
 884   syn off | syn on
 885   AssertNotEqual SyntaxOf('x')[0:2], 'tex'
 886   AssertNotEqual SyntaxOf('y')[0:2], 'tex'
 887
 888 Given markdown;
 889 a
 890
 891 $
 892 b
 893 $
 894
 895 c
 896
 897 Execute (multiline math):
 898   let g:vim_markdown_math=1
 899   syn off | syn on
 900   AssertNotEqual SyntaxOf('a')[0:2], 'tex'
 901   AssertEqual SyntaxOf('b')[0:2], 'tex'
 902   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
 903
 904 Given markdown;
 905 $ \sqrt{a}{b} $
 906 $$ \frac{a}{b} $$
 907
 908 Execute (math tex highlighting):
 909   let g:vim_markdown_math=0
 910   syn off | syn on
 911   AssertNotEqual SyntaxOf('sqrt'), 'texStatement'
 912   AssertNotEqual SyntaxOf('frac'), 'texStatement'
 913   let g:vim_markdown_math=1
 914   syn off | syn on
 915   AssertEqual SyntaxOf('sqrt'), 'texStatement'
 916   AssertEqual SyntaxOf('frac'), 'texStatement'
 917
 918 Given markdown;
 919 $a b[$ c
 920
 921 Execute (math ends with $):
 922   let g:vim_markdown_math=1
 923   syn off | syn on
 924   AssertEqual SyntaxOf('a')[0:2], 'tex'
 925   AssertEqual SyntaxOf('b')[0:2], 'tex'
 926   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
 927
 928 Given markdown;
 929 $$a b[$$ c
 930
 931 Execute (math ends with $$):
 932   let g:vim_markdown_math=1
 933   syn off | syn on
 934   AssertEqual SyntaxOf('a')[0:2], 'tex'
 935   AssertEqual SyntaxOf('b')[0:2], 'tex'
 936   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
 937
 938 Given markdown;
 939 $(0 \le 1)$
 940
 941 Execute (math conceal in $):
 942   if has('conceal')
 943     setlocal conceallevel=2
 944     let g:vim_markdown_math=1
 945     syn off | syn on
 946     AssertEqual synconcealed(1, 1)[0], 1, '$'
 947     AssertEqual synconcealed(1, 2)[0], 0
 948     AssertEqual synconcealed(1, 3)[0], 0
 949     AssertEqual synconcealed(1, 4)[0], 0
 950     AssertEqual synconcealed(1, 5)[0], 1, '\le'
 951     AssertEqual synconcealed(1, 6)[0], 1
 952     AssertEqual synconcealed(1, 7)[0], 1
 953     AssertEqual synconcealed(1, 8)[0], 0
 954     AssertEqual synconcealed(1, 9)[0], 0
 955     AssertEqual synconcealed(1, 10)[0], 0
 956     AssertEqual synconcealed(1, 11)[0], 1, '$'
 957     setlocal conceallevel=0
 958   endif
 959
 960 Given markdown;
 961 $$
 962 \omega
 963 0 \le 1
 964 $$
 965
 966 Execute (math conceal in $$):
 967   if has('conceal')
 968     setlocal conceallevel=2
 969     let g:vim_markdown_math=1
 970     syn off | syn on
 971     AssertEqual synconcealed(1, 1)[0], 1, '$$'
 972     AssertEqual synconcealed(2, 1)[0], 1, '\omega'
 973     AssertEqual synconcealed(3, 1)[0], 0, '0'
 974     AssertEqual synconcealed(3, 3)[0], 1, '\le'
 975     AssertEqual synconcealed(3, 7)[0], 0, '1'
 976     AssertEqual synconcealed(4, 1)[0], 1, '$$'
 977     setlocal conceallevel=0
 978   endif
 979
 980 # YAML frontmatter
 981
 982 Given markdown;
 983 ---
 984 a: b
 985 ---
 986
 987 Execute (YAML frontmatter is controlled by the option):
 988   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
 989   let g:vim_markdown_frontmatter=1
 990   syn off | syn on
 991   AssertEqual SyntaxOf('a')[0:3], 'yaml'
 992   let g:vim_markdown_frontmatter=0
 993   syn off | syn on
 994   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
 995
 996 Given markdown;
 997
 998 ---
 999 a: b
1000 ---
1001
1002 Execute (YAML frontmatter only works if it's the first thing in the file):
1003   let g:vim_markdown_frontmatter=1
1004   syn off | syn on
1005   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
1006
1007 Given markdown;
1008 ---
1009 a: b
1010 ---
1011
1012 ---
1013
1014 Execute (rules are not mistaken by YAML frontmatter delimiters):
1015   let g:vim_markdown_frontmatter=1
1016   syn off | syn on
1017   AssertEqual SyntaxAt(5, 1), 'mkdRule'
1018   unlet g:vim_markdown_frontmatter
1019
1020 # TOML frontmatter
1021
1022 Given markdown;
1023 +++
1024 a = "b"
1025 +++
1026
1027 Execute (TOML frontmatter is controlled by the option):
1028   syn off | syn on
1029   AssertNotEqual SyntaxOf('b'), 'tomlString'
1030   let g:vim_markdown_toml_frontmatter=1
1031   syn off | syn on
1032   AssertEqual SyntaxOf('b'), 'tomlString'
1033   let g:vim_markdown_toml_frontmatter=0
1034   syn off | syn on
1035   AssertNotEqual SyntaxOf('b'), 'tomlString'
1036
1037 Given markdown;
1038
1039 +++
1040 a = "b"
1041 +++
1042
1043 Execute (TOML frontmatter only works if it's the first thing in the file):
1044   let g:vim_markdown_toml_frontmatter=1
1045   syn off | syn on
1046   AssertNotEqual SyntaxOf('b'), 'tomlString'
1047   unlet g:vim_markdown_toml_frontmatter
1048
1049 # JSON frontmatter
1050
1051 Given markdown;
1052 {
1053   "a": "b"
1054 }
1055
1056 Execute (JSON frontmatter is controlled by the option):
1057   syn off | syn on
1058   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
1059   let g:vim_markdown_json_frontmatter=1
1060   syn off | syn on
1061   AssertEqual SyntaxOf('a'), 'jsonKeyword'
1062   let g:vim_markdown_json_frontmatter=0
1063   syn off | syn on
1064   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
1065
1066 Given markdown;
1067
1068 {
1069   "a": "b"
1070 }
1071
1072 Execute (JSON frontmatter only works if it's the first thing in the file):
1073   let g:vim_markdown_json_frontmatter=1
1074   syn off | syn on
1075   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
1076   unlet g:vim_markdown_json_frontmatter
1077
1078 # Header
1079
1080 Given markdown;
1081 # #a
1082 ccc
1083
1084 ## #b
1085 ddd
1086
1087 Execute (header title starts with #):
1088   AssertEqual SyntaxOf('a'), 'htmlH1'
1089   AssertEqual SyntaxOf('b'), 'htmlH2'
1090
1091 Given markdown;
1092 # h1 space
1093
1094 #h1 nospace
1095
1096 #  h1 2 spaces
1097
1098 # h1 trailing hash #
1099
1100 ## h2 space
1101
1102 ##h2 nospace
1103
1104 ## h2 trailing hash ##
1105
1106 ### h3 space
1107
1108 ###h3 nospace
1109
1110 ### h3 trailing hash ###
1111
1112 #### h4
1113
1114 ##### h5
1115
1116 ###### h6
1117
1118 Execute (atx headers):
1119   AssertEqual SyntaxOf('# h1 space'), 'htmlH1'
1120   AssertEqual SyntaxOf('#h1 nospace'), 'htmlH1'
1121   AssertEqual SyntaxOf('#  h1 2 spaces'), 'htmlH1'
1122   AssertEqual SyntaxOf('# h1 trailing hash #'), 'htmlH1'
1123   AssertEqual SyntaxOf('## h2 space'), 'htmlH2'
1124   AssertEqual SyntaxOf('##h2 nospace'), 'htmlH2'
1125   AssertEqual SyntaxOf('## h2 trailing hash ##'), 'htmlH2'
1126   AssertEqual SyntaxOf('### h3 space'), 'htmlH3'
1127   AssertEqual SyntaxOf('###h3 nospace'), 'htmlH3'
1128   AssertEqual SyntaxOf('### h3 trailing hash ###'), 'htmlH3'
1129   AssertEqual SyntaxOf('#### h4'), 'htmlH4'
1130   AssertEqual SyntaxOf('##### h5'), 'htmlH5'
1131   AssertEqual SyntaxOf('###### h6'), 'htmlH6'
1132
1133 Given markdown;
1134 # h1 before h2
1135
1136 ## h2 between h1s
1137
1138 # h1 after h2
1139
1140 Execute (atx headers relative positions):
1141   AssertEqual SyntaxOf('# h1 before h2'), 'htmlH1'
1142   AssertEqual SyntaxOf('## h2 between h1s'), 'htmlH2'
1143   AssertEqual SyntaxOf('# h1 after h2'), 'htmlH1'
1144
1145 Given markdown;
1146 setex h1
1147 ========
1148
1149 setex h2
1150 --------
1151
1152 setex h1 single punctuation
1153 =
1154
1155 setex h1 punctuation longer than header
1156 ================================
1157
1158 Execute (setex headers):
1159   AssertEqual SyntaxOf('setex h1'), 'htmlH1'
1160   AssertEqual SyntaxOf('^========$'), 'htmlH1'
1161   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
1162   AssertEqual SyntaxOf('--------'), 'htmlH2'
1163   AssertEqual SyntaxOf('setex h1 single punctuation'), 'htmlH1'
1164   AssertEqual SyntaxOf('^=$'), 'htmlH1'
1165   AssertEqual SyntaxOf('setex h1 punctuation longer than header'), 'htmlH1'
1166   AssertEqual SyntaxOf('^================================$'), 'htmlH1'
1167
1168 Given markdown;
1169 - not Setex
1170 - because list
1171
1172 Execute (prevent list vs Setex confusion):
1173   AssertNotEqual SyntaxOf('- not Setex'), 'htmlH2'
1174   AssertNotEqual SyntaxOf('- becuase list'), 'htmlH2'
1175
1176 Given markdown;
1177 setex h1 before atx
1178 ===================
1179
1180 ## atx h2
1181
1182 ### atx h3
1183
1184 # atx h1
1185
1186 setex h2
1187 ------------------
1188
1189 ### atx h3 2
1190
1191 Execute (mixed atx and setex headers):
1192   AssertEqual SyntaxOf('setex h1 before atx'), 'htmlH1'
1193   AssertEqual SyntaxOf('==================='), 'htmlH1'
1194   AssertEqual SyntaxOf('## atx h2'), 'htmlH2'
1195   AssertEqual SyntaxOf('### atx h3'), 'htmlH3'
1196   AssertEqual SyntaxOf('# atx h1'), 'htmlH1'
1197   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
1198   AssertEqual SyntaxOf('------------------'), 'htmlH2'
1199
1200 # List
1201
1202 Given markdown;
1203 - a & b
1204 1. c > d
1205
1206 Execute (& and > are not marked as htmlError in lists):
1207   AssertEqual SyntaxOf('-'), 'mkdListItem'
1208   AssertEqual SyntaxOf('1.'), 'mkdListItem'
1209   AssertNotEqual SyntaxOf('&'), 'htmlError'
1210   AssertNotEqual SyntaxOf('>'), 'htmlError'
1211
1212 Given markdown;
1213 1. a
1214 2. b
1215
1216 Execute (list after line break):
1217   AssertEqual SyntaxOf('1'), 'mkdListItem'
1218   AssertEqual SyntaxOf('2'), 'mkdListItem'
1219
1220 # HTML
1221
1222 Given markdown;
1223 a
1224
1225 <p>b</p>
1226
1227 - <span>c</span>
1228
1229 Execute (HTML tag in text):
1230   AssertEqual SyntaxOf('p'), 'htmlTagName'
1231   AssertEqual SyntaxOf('<p>'), 'htmlTag'
1232   AssertEqual SyntaxOf('</p>'), 'htmlEndTag'
1233   AssertEqual SyntaxOf('span'), 'htmlTagName'
1234   AssertEqual SyntaxOf('<span>'), 'htmlTag'
1235   AssertEqual SyntaxOf('</span>'), 'htmlEndTag'