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