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 # Code Blocks
 633
 634 Given markdown;
 635 ~~~
 636 code
 637 ~~~
 638
 639 Execute (code blocks can be fenced with tildes):
 640   AssertEqual SyntaxOf('c'), 'mkdCode'
 641
 642 Given markdown;
 643 ~~~~
 644 code
 645 ~~~~~
 646
 647 Execute (code blocks can be fenced with tildes longer than 3):
 648   AssertEqual SyntaxOf('c'), 'mkdCode'
 649
 650 Given markdown;
 651 ````
 652 code
 653 `````
 654
 655 Execute (code blocks can be fenced with backticks longer than 3):
 656   AssertEqual SyntaxOf('c'), 'mkdCode'
 657
 658 Given markdown;
 659 ~~~ruby
 660 code
 661 ~~~
 662
 663 Execute (code blocks can have a language specifier):
 664   AssertEqual SyntaxOf('c'), 'mkdCode'
 665
 666 Given markdown;
 667 ```c++
 668 code
 669 ```
 670
 671 text
 672
 673 Execute (code blocks can be fenced with backticks and a language specifier):
 674   AssertEqual SyntaxOf('code'), 'mkdCode'
 675   AssertNotEqual SyntaxOf('text'), 'mkdCode'
 676
 677 # Indent Code Blocks
 678
 679 Given markdown;
 680 a
 681
 682     b
 683     c
 684
 685 Execute (indent code blocks):
 686   AssertNotEqual SyntaxOf('a'), 'mkdCode'
 687   AssertEqual SyntaxOf('b'), 'mkdCode'
 688   AssertEqual SyntaxOf('c'), 'mkdCode'
 689
 690 Given markdown;
 691 # a
 692
 693 b
 694
 695     c
 696
 697 Execute (indent code blocks after header):
 698   AssertNotEqual SyntaxOf('a'), 'mkdCode'
 699   AssertNotEqual SyntaxOf('b'), 'mkdCode'
 700   AssertEqual SyntaxOf('c'), 'mkdCode'
 701
 702 Given markdown;
 703 -   a
 704
 705     b
 706
 707         c
 708
 709 Execute (indent code blocks after list):
 710   AssertNotEqual SyntaxOf('a'), 'mkdCode'
 711   AssertNotEqual SyntaxOf('b'), 'mkdCode'
 712   AssertEqual SyntaxOf('c'), 'mkdCode'
 713
 714 Given markdown;
 715     a
 716     b
 717
 718 Execute (indent code block at beginning of file):
 719   AssertEqual SyntaxOf('a'), 'mkdCode'
 720   AssertEqual SyntaxOf('b'), 'mkdCode'
 721
 722 Given markdown;
 723 ```c++
 724 #include <iostream>
 725 code
 726 ```
 727
 728 ```ruby
 729 def a
 730 end
 731 ```
 732
 733 Execute (fenced code block syntax with a language specifier):
 734   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
 735   call b:func(0)
 736   AssertEqual SyntaxOf('include'), 'cInclude'
 737   AssertEqual SyntaxOf('code'), 'mkdSnippetCPP'
 738   AssertEqual SyntaxOf('def'), 'rubyDefine'
 739
 740 Given markdown;
 741 ``` c++
 742 #include <iostream>
 743 code
 744 ```
 745
 746 ```  vim
 747 let g:a = 1
 748 ```
 749
 750 ```     ruby
 751 def a
 752 end
 753 ```
 754
 755 ```
 756 ruby
 757 class B
 758 end
 759 ```
 760
 761 Execute (fenced code block syntax with a language specifier after whitespace):
 762   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
 763   call b:func(0)
 764   AssertEqual SyntaxOf('include'), 'cInclude'
 765   AssertEqual SyntaxOf('code'), 'mkdSnippetCPP'
 766   AssertEqual SyntaxOf('g:a'), 'vimVar'
 767   AssertEqual SyntaxOf('def'), 'rubyDefine'
 768   AssertNotEqual SyntaxOf('class'), 'rubyClass'
 769
 770 Given markdown;
 771 ```vim
 772 let g:a = 1
 773 ```
 774
 775 ```viml
 776 let g:b = 1
 777 ```
 778
 779 Execute (fenced code block syntax with alias language specifier):
 780   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
 781   call b:func(0)
 782   AssertEqual SyntaxOf('g:a'), 'vimVar'
 783   AssertEqual SyntaxOf('g:b'), 'vimVar'
 784
 785 Given markdown;
 786 ```csharp
 787 var s = "foo";
 788 ```
 789
 790 Execute (fenced code block languages setting):
 791   let g:vim_markdown_fenced_languages = ['csharp=cs']
 792   source ../ftplugin/markdown.vim
 793   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
 794   call b:func(0)
 795   AssertEqual SyntaxOf('foo'), 'csString'
 796   unlet g:vim_markdown_fenced_languages
 797
 798 Given markdown;
 799 ```vim
 800 let g:a = 1
 801 ```
 802
 803 Execute (fenced code block includes language syntax with reopening same buffer):
 804   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
 805   call b:func(0)
 806   split
 807   quit
 808   edit
 809   set filetype=markdown
 810   execute "normal! i```vim\<cr>let g:a = 1\<cr>```"
 811   call b:func(1)
 812   AssertEqual SyntaxOf('g:a'), 'vimVar'
 813
 814 Given markdown;
 815 ```a+b-
 816 code
 817 ```
 818
 819 Execute (fenced code block syntax with an unknown language specifier):
 820   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
 821   call b:func(0)
 822   AssertEqual SyntaxOf('code'), 'mkdSnippetA_B_'
 823
 824 Given markdown;
 825 ```
 826 =
 827 a
 828 -
 829 ```
 830
 831 Execute (first = or - in fenced code block is not setex headers):
 832   AssertEqual SyntaxOf('='), 'mkdCode'
 833   AssertEqual SyntaxOf('-'), 'mkdCode'
 834
 835 Given markdown;
 836 ``` {style=""}
 837 a
 838 ```
 839
 840 Execute (fenced code block with extended info strings):
 841   AssertEqual SyntaxOf('a'), 'mkdCode'
 842
 843 # Code Blocks in pre and code tag
 844
 845 Given markdown;
 846 <pre>
 847 a
 848 </pre>
 849
 850 Execute (code block in pre tag):
 851   AssertEqual SyntaxOf('a'), 'mkdCode'
 852
 853 Given markdown;
 854 <code>
 855 a
 856 </code>
 857
 858 Execute (code block in code tag):
 859   AssertEqual SyntaxOf('a'), 'mkdCode'
 860
 861 Given markdown;
 862 \<pre\>
 863 a
 864 \</pre\>
 865
 866 Execute (not code block in escaped pre tag):
 867   AssertNotEqual SyntaxOf('a'), 'mkdCode'
 868
 869 Given markdown;
 870 \<code\>
 871 a
 872 \</code\>
 873
 874 Execute (not code block in escaped code tag):
 875   AssertNotEqual SyntaxOf('a'), 'mkdCode'
 876
 877 # Math
 878
 879 Given markdown;
 880 a $x$ b
 881 c $$y$$ d
 882 \$e\$
 883 \$\$f\$\$
 884
 885 Execute (math):
 886   AssertNotEqual SyntaxOf('x')[0:2], 'tex'
 887   AssertNotEqual SyntaxOf('y')[0:2], 'tex'
 888   let g:vim_markdown_math=1
 889   syn off | syn on
 890   AssertNotEqual SyntaxOf('a')[0:2], 'tex'
 891   AssertNotEqual SyntaxOf('b')[0:2], 'tex'
 892   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
 893   AssertNotEqual SyntaxOf('d')[0:2], 'tex'
 894   AssertNotEqual SyntaxOf('e')[0:2], 'tex'
 895   AssertNotEqual SyntaxOf('f')[0:2], 'tex'
 896   AssertEqual SyntaxOf('x')[0:2], 'tex'
 897   AssertEqual SyntaxOf('y')[0:2], 'tex'
 898   let g:vim_markdown_math=0
 899   syn off | syn on
 900   AssertNotEqual SyntaxOf('x')[0:2], 'tex'
 901   AssertNotEqual SyntaxOf('y')[0:2], 'tex'
 902
 903 Given markdown;
 904 a
 905
 906 $
 907 b
 908 $
 909
 910 c
 911
 912 Execute (multiline math):
 913   let g:vim_markdown_math=1
 914   syn off | syn on
 915   AssertNotEqual SyntaxOf('a')[0:2], 'tex'
 916   AssertEqual SyntaxOf('b')[0:2], 'tex'
 917   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
 918
 919 Given markdown;
 920 $ \sqrt{a}{b} $
 921 $$ \frac{a}{b} $$
 922
 923 Execute (math tex highlighting):
 924   let g:vim_markdown_math=0
 925   syn off | syn on
 926   AssertNotEqual SyntaxOf('sqrt'), 'texStatement'
 927   AssertNotEqual SyntaxOf('frac'), 'texStatement'
 928   let g:vim_markdown_math=1
 929   syn off | syn on
 930   AssertEqual SyntaxOf('sqrt'), 'texStatement'
 931   AssertEqual SyntaxOf('frac'), 'texStatement'
 932
 933 Given markdown;
 934 $a b[$ c
 935
 936 Execute (math ends with $):
 937   let g:vim_markdown_math=1
 938   syn off | syn on
 939   AssertEqual SyntaxOf('a')[0:2], 'tex'
 940   AssertEqual SyntaxOf('b')[0:2], 'tex'
 941   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
 942
 943 Given markdown;
 944 $$a b[$$ c
 945
 946 Execute (math ends with $$):
 947   let g:vim_markdown_math=1
 948   syn off | syn on
 949   AssertEqual SyntaxOf('a')[0:2], 'tex'
 950   AssertEqual SyntaxOf('b')[0:2], 'tex'
 951   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
 952
 953 Given markdown;
 954 $(0 \le 1)$
 955
 956 Execute (math conceal in $):
 957   if has('conceal')
 958     setlocal conceallevel=2
 959     let g:vim_markdown_math=1
 960     syn off | syn on
 961     AssertEqual synconcealed(1, 1)[0], 1, '$'
 962     AssertEqual synconcealed(1, 2)[0], 0
 963     AssertEqual synconcealed(1, 3)[0], 0
 964     AssertEqual synconcealed(1, 4)[0], 0
 965     AssertEqual synconcealed(1, 5)[0], 1, '\le'
 966     AssertEqual synconcealed(1, 6)[0], 1
 967     AssertEqual synconcealed(1, 7)[0], 1
 968     AssertEqual synconcealed(1, 8)[0], 0
 969     AssertEqual synconcealed(1, 9)[0], 0
 970     AssertEqual synconcealed(1, 10)[0], 0
 971     AssertEqual synconcealed(1, 11)[0], 1, '$'
 972     setlocal conceallevel=0
 973   endif
 974
 975 Given markdown;
 976 $$
 977 \omega
 978 0 \le 1
 979 $$
 980
 981 Execute (math conceal in $$):
 982   if has('conceal')
 983     setlocal conceallevel=2
 984     let g:vim_markdown_math=1
 985     syn off | syn on
 986     AssertEqual synconcealed(1, 1)[0], 1, '$$'
 987     AssertEqual synconcealed(2, 1)[0], 1, '\omega'
 988     AssertEqual synconcealed(3, 1)[0], 0, '0'
 989     AssertEqual synconcealed(3, 3)[0], 1, '\le'
 990     AssertEqual synconcealed(3, 7)[0], 0, '1'
 991     AssertEqual synconcealed(4, 1)[0], 1, '$$'
 992     setlocal conceallevel=0
 993   endif
 994
 995 # YAML frontmatter
 996
 997 Given markdown;
 998 ---
 999 a: b
1000 ---
1001
1002 Execute (YAML frontmatter is controlled by the option):
1003   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
1004   let g:vim_markdown_frontmatter=1
1005   syn off | syn on
1006   AssertEqual SyntaxOf('a')[0:3], 'yaml'
1007   let g:vim_markdown_frontmatter=0
1008   syn off | syn on
1009   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
1010
1011 Given markdown;
1012
1013 ---
1014 a: b
1015 ---
1016
1017 Execute (YAML frontmatter only works if it's the first thing in the file):
1018   let g:vim_markdown_frontmatter=1
1019   syn off | syn on
1020   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
1021
1022 Given markdown;
1023 ---
1024 a: b
1025 ---
1026
1027 ---
1028
1029 Execute (rules are not mistaken by YAML frontmatter delimiters):
1030   let g:vim_markdown_frontmatter=1
1031   syn off | syn on
1032   AssertEqual SyntaxAt(5, 1), 'mkdRule'
1033   unlet g:vim_markdown_frontmatter
1034
1035 # TOML frontmatter
1036
1037 Given markdown;
1038 +++
1039 a = "b"
1040 +++
1041
1042 Execute (TOML frontmatter is controlled by the option):
1043   syn off | syn on
1044   AssertNotEqual SyntaxOf('b'), 'tomlString'
1045   let g:vim_markdown_toml_frontmatter=1
1046   syn off | syn on
1047   AssertEqual SyntaxOf('b'), 'tomlString'
1048   let g:vim_markdown_toml_frontmatter=0
1049   syn off | syn on
1050   AssertNotEqual SyntaxOf('b'), 'tomlString'
1051
1052 Given markdown;
1053
1054 +++
1055 a = "b"
1056 +++
1057
1058 Execute (TOML frontmatter only works if it's the first thing in the file):
1059   let g:vim_markdown_toml_frontmatter=1
1060   syn off | syn on
1061   AssertNotEqual SyntaxOf('b'), 'tomlString'
1062   unlet g:vim_markdown_toml_frontmatter
1063
1064 # JSON frontmatter
1065
1066 Given markdown;
1067 {
1068   "a": "b"
1069 }
1070
1071 Execute (JSON frontmatter is controlled by the option):
1072   syn off | syn on
1073   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
1074   let g:vim_markdown_json_frontmatter=1
1075   syn off | syn on
1076   AssertEqual SyntaxOf('a'), 'jsonKeyword'
1077   let g:vim_markdown_json_frontmatter=0
1078   syn off | syn on
1079   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
1080
1081 Given markdown;
1082
1083 {
1084   "a": "b"
1085 }
1086
1087 Execute (JSON frontmatter only works if it's the first thing in the file):
1088   let g:vim_markdown_json_frontmatter=1
1089   syn off | syn on
1090   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
1091   unlet g:vim_markdown_json_frontmatter
1092
1093 # Header
1094
1095 Given markdown;
1096 # #a
1097 ccc
1098
1099 ## #b
1100 ddd
1101
1102 Execute (header title starts with #):
1103   AssertEqual SyntaxOf('a'), 'htmlH1'
1104   AssertEqual SyntaxOf('b'), 'htmlH2'
1105
1106 Given markdown;
1107 # h1 space
1108
1109 #h1 nospace
1110
1111 #  h1 2 spaces
1112
1113 # h1 trailing hash #
1114
1115 ## h2 space
1116
1117 ##h2 nospace
1118
1119 ## h2 trailing hash ##
1120
1121 ### h3 space
1122
1123 ###h3 nospace
1124
1125 ### h3 trailing hash ###
1126
1127 #### h4
1128
1129 ##### h5
1130
1131 ###### h6
1132
1133 Execute (atx headers):
1134   AssertEqual SyntaxOf('# h1 space'), 'htmlH1'
1135   AssertEqual SyntaxOf('#h1 nospace'), 'htmlH1'
1136   AssertEqual SyntaxOf('#  h1 2 spaces'), 'htmlH1'
1137   AssertEqual SyntaxOf('# h1 trailing hash #'), 'htmlH1'
1138   AssertEqual SyntaxOf('## h2 space'), 'htmlH2'
1139   AssertEqual SyntaxOf('##h2 nospace'), 'htmlH2'
1140   AssertEqual SyntaxOf('## h2 trailing hash ##'), 'htmlH2'
1141   AssertEqual SyntaxOf('### h3 space'), 'htmlH3'
1142   AssertEqual SyntaxOf('###h3 nospace'), 'htmlH3'
1143   AssertEqual SyntaxOf('### h3 trailing hash ###'), 'htmlH3'
1144   AssertEqual SyntaxOf('#### h4'), 'htmlH4'
1145   AssertEqual SyntaxOf('##### h5'), 'htmlH5'
1146   AssertEqual SyntaxOf('###### h6'), 'htmlH6'
1147
1148 Given markdown;
1149 # h1 before h2
1150
1151 ## h2 between h1s
1152
1153 # h1 after h2
1154
1155 Execute (atx headers relative positions):
1156   AssertEqual SyntaxOf('# h1 before h2'), 'htmlH1'
1157   AssertEqual SyntaxOf('## h2 between h1s'), 'htmlH2'
1158   AssertEqual SyntaxOf('# h1 after h2'), 'htmlH1'
1159
1160 Given markdown;
1161 setex h1
1162 ========
1163
1164 setex h2
1165 --------
1166
1167 setex h1 single punctuation
1168 =
1169
1170 setex h1 punctuation longer than header
1171 ================================
1172
1173 Execute (setex headers):
1174   AssertEqual SyntaxOf('setex h1'), 'htmlH1'
1175   AssertEqual SyntaxOf('^========$'), 'htmlH1'
1176   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
1177   AssertEqual SyntaxOf('--------'), 'htmlH2'
1178   AssertEqual SyntaxOf('setex h1 single punctuation'), 'htmlH1'
1179   AssertEqual SyntaxOf('^=$'), 'htmlH1'
1180   AssertEqual SyntaxOf('setex h1 punctuation longer than header'), 'htmlH1'
1181   AssertEqual SyntaxOf('^================================$'), 'htmlH1'
1182
1183 Given markdown;
1184 - not Setex
1185 - because list
1186
1187 Execute (prevent list vs Setex confusion):
1188   AssertNotEqual SyntaxOf('- not Setex'), 'htmlH2'
1189   AssertNotEqual SyntaxOf('- becuase list'), 'htmlH2'
1190
1191 Given markdown;
1192 setex h1 before atx
1193 ===================
1194
1195 ## atx h2
1196
1197 ### atx h3
1198
1199 # atx h1
1200
1201 setex h2
1202 ------------------
1203
1204 ### atx h3 2
1205
1206 Execute (mixed atx and setex headers):
1207   AssertEqual SyntaxOf('setex h1 before atx'), 'htmlH1'
1208   AssertEqual SyntaxOf('==================='), 'htmlH1'
1209   AssertEqual SyntaxOf('## atx h2'), 'htmlH2'
1210   AssertEqual SyntaxOf('### atx h3'), 'htmlH3'
1211   AssertEqual SyntaxOf('# atx h1'), 'htmlH1'
1212   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
1213   AssertEqual SyntaxOf('------------------'), 'htmlH2'
1214
1215 # List
1216
1217 Given markdown;
1218 - a & b
1219 1. c > d
1220
1221 Execute (& and > are not marked as htmlError in lists):
1222   AssertEqual SyntaxOf('-'), 'mkdListItem'
1223   AssertEqual SyntaxOf('1.'), 'mkdListItem'
1224   AssertNotEqual SyntaxOf('&'), 'htmlError'
1225   AssertNotEqual SyntaxOf('>'), 'htmlError'
1226
1227 Given markdown;
1228 1. a
1229 2. b
1230
1231 Execute (list after line break):
1232   AssertEqual SyntaxOf('1'), 'mkdListItem'
1233   AssertEqual SyntaxOf('2'), 'mkdListItem'
1234
1235 # HTML
1236
1237 Given markdown;
1238 a
1239
1240 <p>b</p>
1241
1242 - <span>c</span>
1243
1244 Execute (HTML tag in text):
1245   AssertEqual SyntaxOf('p'), 'htmlTagName'
1246   AssertEqual SyntaxOf('<p>'), 'htmlTag'
1247   AssertEqual SyntaxOf('</p>'), 'htmlEndTag'
1248   AssertEqual SyntaxOf('span'), 'htmlTagName'
1249   AssertEqual SyntaxOf('<span>'), 'htmlTag'
1250   AssertEqual SyntaxOf('</span>'), 'htmlEndTag'