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