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 Given markdown;
 903 ``a\`` b ``c`\`1`` d
 904
 905 Execute (double code quotes not escaped ending with backslash):
 906   AssertEqual SyntaxOf('a\'), 'mkdCode'
 907   AssertNotEqual SyntaxOf('b'), 'mkdCode'
 908   AssertEqual SyntaxOf('c`\\`1'), 'mkdCode'
 909   AssertNotEqual SyntaxOf('d'), 'mkdCode'
 910
 911 # Math
 912
 913 Given markdown;
 914 a $x$ b
 915 c $$y$$ d
 916 \$e\$
 917 \$\$f\$\$
 918
 919 Execute (math):
 920   AssertNotEqual SyntaxOf('x')[0:2], 'tex'
 921   AssertNotEqual SyntaxOf('y')[0:2], 'tex'
 922   let g:vim_markdown_math=1
 923   syn off | syn on
 924   AssertNotEqual SyntaxOf('a')[0:2], 'tex'
 925   AssertNotEqual SyntaxOf('b')[0:2], 'tex'
 926   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
 927   AssertNotEqual SyntaxOf('d')[0:2], 'tex'
 928   AssertNotEqual SyntaxOf('e')[0:2], 'tex'
 929   AssertNotEqual SyntaxOf('f')[0:2], 'tex'
 930   AssertEqual SyntaxOf('x')[0:2], 'tex'
 931   AssertEqual SyntaxOf('y')[0:2], 'tex'
 932   let g:vim_markdown_math=0
 933   syn off | syn on
 934   AssertNotEqual SyntaxOf('x')[0:2], 'tex'
 935   AssertNotEqual SyntaxOf('y')[0:2], 'tex'
 936
 937 Given markdown;
 938 a
 939
 940 $
 941 b
 942 $
 943
 944 c
 945
 946 Execute (multiline math):
 947   let g:vim_markdown_math=1
 948   syn off | syn on
 949   AssertNotEqual SyntaxOf('a')[0:2], 'tex'
 950   AssertEqual SyntaxOf('b')[0:2], 'tex'
 951   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
 952
 953 Given markdown;
 954 $ \sqrt{a}{b} $
 955 $$ \frac{a}{b} $$
 956
 957 Execute (math tex highlighting):
 958   let g:vim_markdown_math=0
 959   syn off | syn on
 960   AssertNotEqual SyntaxOf('sqrt'), 'texStatement'
 961   AssertNotEqual SyntaxOf('frac'), 'texStatement'
 962   let g:vim_markdown_math=1
 963   syn off | syn on
 964   AssertEqual SyntaxOf('sqrt'), 'texStatement'
 965   AssertEqual SyntaxOf('frac'), 'texStatement'
 966
 967 Given markdown;
 968 $a b[$ c
 969
 970 Execute (math ends with $):
 971   let g:vim_markdown_math=1
 972   syn off | syn on
 973   AssertEqual SyntaxOf('a')[0:2], 'tex'
 974   AssertEqual SyntaxOf('b')[0:2], 'tex'
 975   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
 976
 977 Given markdown;
 978 $$a b[$$ c
 979
 980 Execute (math ends with $$):
 981   let g:vim_markdown_math=1
 982   syn off | syn on
 983   AssertEqual SyntaxOf('a')[0:2], 'tex'
 984   AssertEqual SyntaxOf('b')[0:2], 'tex'
 985   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
 986
 987 Given markdown;
 988 $(0 \le 1)$
 989
 990 Execute (math conceal in $):
 991   if has('conceal')
 992     setlocal conceallevel=2
 993     let g:vim_markdown_math=1
 994     syn off | syn on
 995     AssertEqual synconcealed(1, 1)[0], 1, '$'
 996     AssertEqual synconcealed(1, 2)[0], 0
 997     AssertEqual synconcealed(1, 3)[0], 0
 998     AssertEqual synconcealed(1, 4)[0], 0
 999     AssertEqual synconcealed(1, 5)[0], 1, '\le'
1000     AssertEqual synconcealed(1, 6)[0], 1
1001     AssertEqual synconcealed(1, 7)[0], 1
1002     AssertEqual synconcealed(1, 8)[0], 0
1003     AssertEqual synconcealed(1, 9)[0], 0
1004     AssertEqual synconcealed(1, 10)[0], 0
1005     AssertEqual synconcealed(1, 11)[0], 1, '$'
1006     setlocal conceallevel=0
1007   endif
1008
1009 Given markdown;
1010 $$
1011 \omega
1012 0 \le 1
1013 $$
1014
1015 Execute (math conceal in $$):
1016   if has('conceal')
1017     setlocal conceallevel=2
1018     let g:vim_markdown_math=1
1019     syn off | syn on
1020     AssertEqual synconcealed(1, 1)[0], 1, '$$'
1021     AssertEqual synconcealed(2, 1)[0], 1, '\omega'
1022     AssertEqual synconcealed(3, 1)[0], 0, '0'
1023     AssertEqual synconcealed(3, 3)[0], 1, '\le'
1024     AssertEqual synconcealed(3, 7)[0], 0, '1'
1025     AssertEqual synconcealed(4, 1)[0], 1, '$$'
1026     setlocal conceallevel=0
1027   endif
1028
1029 # YAML frontmatter
1030
1031 Given markdown;
1032 ---
1033 a: b
1034 ---
1035
1036 Execute (YAML frontmatter is controlled by the option):
1037   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
1038   let g:vim_markdown_frontmatter=1
1039   syn off | syn on
1040   AssertEqual SyntaxOf('a')[0:3], 'yaml'
1041   let g:vim_markdown_frontmatter=0
1042   syn off | syn on
1043   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
1044
1045 Given markdown;
1046
1047 ---
1048 a: b
1049 ---
1050
1051 Execute (YAML frontmatter only works if it's the first thing in the file):
1052   let g:vim_markdown_frontmatter=1
1053   syn off | syn on
1054   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
1055
1056 Given markdown;
1057 ---
1058 a: b
1059 ---
1060
1061 ---
1062
1063 Execute (rules are not mistaken by YAML frontmatter delimiters):
1064   let g:vim_markdown_frontmatter=1
1065   syn off | syn on
1066   AssertEqual SyntaxAt(5, 1), 'mkdRule'
1067   unlet g:vim_markdown_frontmatter
1068
1069 # TOML frontmatter
1070
1071 Given markdown;
1072 +++
1073 a = "b"
1074 +++
1075
1076 Execute (TOML frontmatter is controlled by the option):
1077   syn off | syn on
1078   AssertNotEqual SyntaxOf('b'), 'tomlString'
1079   let g:vim_markdown_toml_frontmatter=1
1080   syn off | syn on
1081   AssertEqual SyntaxOf('b'), 'tomlString'
1082   let g:vim_markdown_toml_frontmatter=0
1083   syn off | syn on
1084   AssertNotEqual SyntaxOf('b'), 'tomlString'
1085
1086 Given markdown;
1087
1088 +++
1089 a = "b"
1090 +++
1091
1092 Execute (TOML frontmatter only works if it's the first thing in the file):
1093   let g:vim_markdown_toml_frontmatter=1
1094   syn off | syn on
1095   AssertNotEqual SyntaxOf('b'), 'tomlString'
1096   unlet g:vim_markdown_toml_frontmatter
1097
1098 # JSON frontmatter
1099
1100 Given markdown;
1101 {
1102   "a": "b"
1103 }
1104
1105 Execute (JSON frontmatter is controlled by the option):
1106   syn off | syn on
1107   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
1108   let g:vim_markdown_json_frontmatter=1
1109   syn off | syn on
1110   AssertEqual SyntaxOf('a'), 'jsonKeyword'
1111   let g:vim_markdown_json_frontmatter=0
1112   syn off | syn on
1113   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
1114
1115 Given markdown;
1116
1117 {
1118   "a": "b"
1119 }
1120
1121 Execute (JSON frontmatter only works if it's the first thing in the file):
1122   let g:vim_markdown_json_frontmatter=1
1123   syn off | syn on
1124   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
1125   unlet g:vim_markdown_json_frontmatter
1126
1127 # Header
1128
1129 Given markdown;
1130 # #a
1131 ccc
1132
1133 ## #b
1134 ddd
1135
1136 Execute (header title starts with #):
1137   AssertEqual SyntaxOf('a'), 'htmlH1'
1138   AssertEqual SyntaxOf('b'), 'htmlH2'
1139
1140 Given markdown;
1141 # h1 space
1142
1143 #h1 nospace
1144
1145 #  h1 2 spaces
1146
1147 # h1 trailing hash #
1148
1149 ## h2 space
1150
1151 ##h2 nospace
1152
1153 ## h2 trailing hash ##
1154
1155 ### h3 space
1156
1157 ###h3 nospace
1158
1159 ### h3 trailing hash ###
1160
1161 #### h4
1162
1163 ##### h5
1164
1165 ###### h6
1166
1167 Execute (atx headers):
1168   AssertEqual SyntaxOf(' h1 space'), 'htmlH1'
1169   AssertEqual SyntaxOf('h1 nospace'), 'htmlH1'
1170   AssertEqual SyntaxOf('  h1 2 spaces'), 'htmlH1'
1171   AssertEqual SyntaxOf(' h1 trailing hash '), 'htmlH1'
1172   AssertEqual SyntaxOf(' h2 space'), 'htmlH2'
1173   AssertEqual SyntaxOf('h2 nospace'), 'htmlH2'
1174   AssertEqual SyntaxOf(' h2 trailing hash '), 'htmlH2'
1175   AssertEqual SyntaxOf(' h3 space'), 'htmlH3'
1176   AssertEqual SyntaxOf('h3 nospace'), 'htmlH3'
1177   AssertEqual SyntaxOf(' h3 trailing hash '), 'htmlH3'
1178   AssertEqual SyntaxOf(' h4'), 'htmlH4'
1179   AssertEqual SyntaxOf(' h5'), 'htmlH5'
1180   AssertEqual SyntaxOf(' h6'), 'htmlH6'
1181
1182 Given markdown;
1183 # h1 before h2
1184
1185 ## h2 between h1s
1186
1187 # h1 after h2
1188
1189 Execute (atx headers relative positions):
1190   AssertEqual SyntaxOf(' h1 before h2'), 'htmlH1'
1191   AssertEqual SyntaxOf(' h2 between h1s'), 'htmlH2'
1192   AssertEqual SyntaxOf(' h1 after h2'), 'htmlH1'
1193
1194 Given markdown;
1195 setex h1
1196 ========
1197
1198 setex h2
1199 --------
1200
1201 setex h1 single punctuation
1202 =
1203
1204 setex h1 punctuation longer than header
1205 ================================
1206
1207 Execute (setex headers):
1208   AssertEqual SyntaxOf('setex h1'), 'htmlH1'
1209   AssertEqual SyntaxOf('^========$'), 'htmlH1'
1210   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
1211   AssertEqual SyntaxOf('--------'), 'htmlH2'
1212   AssertEqual SyntaxOf('setex h1 single punctuation'), 'htmlH1'
1213   AssertEqual SyntaxOf('^=$'), 'htmlH1'
1214   AssertEqual SyntaxOf('setex h1 punctuation longer than header'), 'htmlH1'
1215   AssertEqual SyntaxOf('^================================$'), 'htmlH1'
1216
1217 Given markdown;
1218 - not Setex
1219 - because list
1220
1221 Execute (prevent list vs Setex confusion):
1222   AssertNotEqual SyntaxOf('- not Setex'), 'htmlH2'
1223   AssertNotEqual SyntaxOf('- becuase list'), 'htmlH2'
1224
1225 Given markdown;
1226 setex h1 before atx
1227 ===================
1228
1229 ## atx h2
1230
1231 ### atx h3
1232
1233 # atx h1
1234
1235 setex h2
1236 ------------------
1237
1238 ### atx h3 2
1239
1240 Execute (mixed atx and setex headers):
1241   AssertEqual SyntaxOf('setex h1 before atx'), 'htmlH1'
1242   AssertEqual SyntaxOf('==================='), 'htmlH1'
1243   AssertEqual SyntaxOf(' atx h2'), 'htmlH2'
1244   AssertEqual SyntaxOf(' atx h3'), 'htmlH3'
1245   AssertEqual SyntaxOf(' atx h1'), 'htmlH1'
1246   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
1247   AssertEqual SyntaxOf('------------------'), 'htmlH2'
1248
1249 # List
1250
1251 Given markdown;
1252 - a & b
1253 1. c > d
1254
1255 Execute (& and > are not marked as htmlError in lists):
1256   AssertEqual SyntaxOf('-'), 'mkdListItem'
1257   AssertEqual SyntaxOf('1.'), 'mkdListItem'
1258   AssertNotEqual SyntaxOf('&'), 'htmlError'
1259   AssertNotEqual SyntaxOf('>'), 'htmlError'
1260
1261 Given markdown;
1262 1. a
1263 2. b
1264
1265 Execute (list after line break):
1266   AssertEqual SyntaxOf('1'), 'mkdListItem'
1267   AssertEqual SyntaxOf('2'), 'mkdListItem'
1268
1269 # HTML
1270
1271 Given markdown;
1272 a
1273
1274 <p>b</p>
1275
1276 - <span>c</span>
1277
1278 Execute (HTML tag in text):
1279   AssertEqual SyntaxOf('p'), 'htmlTagName'
1280   AssertEqual SyntaxOf('<p>'), 'htmlTag'
1281   AssertEqual SyntaxOf('</p>'), 'htmlEndTag'
1282   AssertEqual SyntaxOf('span'), 'htmlTagName'
1283   AssertEqual SyntaxOf('<span>'), 'htmlTag'
1284   AssertEqual SyntaxOf('</span>'), 'htmlEndTag'