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