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'