.vim/bundle/vim-markdown/test/syntax.vader

   1 Before:
   2   unlet! b:mkd_known_filetypes
   3   unlet! b:mkd_included_filetypes
   4   unlet! g:vim_markdown_math
   5   unlet! b:liquid_subtype
   6
   7 Given markdown;
   8 a **b** c
   9
  10 Execute (bold):
  11   AssertNotEqual SyntaxOf('a'), 'htmlBold'
  12   AssertEqual SyntaxOf('b'), 'htmlBold'
  13   AssertNotEqual SyntaxOf('c'), 'htmlBold'
  14
  15 Given markdown;
  16 a __b__ c
  17
  18 Execute (bold):
  19   AssertNotEqual SyntaxOf('a'), 'htmlBold'
  20   AssertEqual SyntaxOf('b'), 'htmlBold'
  21   AssertNotEqual SyntaxOf('c'), 'htmlBold'
  22
  23 Given markdown;
  24 a *b* c
  25
  26 Execute (italic):
  27   AssertNotEqual SyntaxOf('a'), 'htmlItalic'
  28   AssertEqual SyntaxOf('b'), 'htmlItalic'
  29   AssertNotEqual SyntaxOf('c'), 'htmlItalic'
  30
  31 Given markdown;
  32 a _b_ c
  33
  34 Execute (italic):
  35   AssertNotEqual SyntaxOf('a'), 'htmlItalic'
  36   AssertEqual SyntaxOf('b'), 'htmlItalic'
  37   AssertNotEqual SyntaxOf('c'), 'htmlItalic'
  38
  39 Given markdown;
  40 _a_b_
  41
  42 Execute (italic text has underscores):
  43   AssertEqual SyntaxOf('a'), 'htmlItalic'
  44   AssertEqual SyntaxOf('b'), 'htmlItalic'
  45
  46 Given markdown;
  47 a \*b\* c
  48
  49 Execute (not italic with escaped asterisks):
  50   AssertNotEqual SyntaxOf('a'), 'htmlItalic'
  51   AssertNotEqual SyntaxOf('b'), 'htmlItalic'
  52   AssertNotEqual SyntaxOf('c'), 'htmlItalic'
  53
  54 Given markdown;
  55 a \_b\_ c
  56
  57 Execute (not italic with escaped underscores):
  58   AssertNotEqual SyntaxOf('a'), 'htmlItalic'
  59   AssertNotEqual SyntaxOf('b'), 'htmlItalic'
  60   AssertNotEqual SyntaxOf('c'), 'htmlItalic'
  61
  62 Given markdown;
  63 a _b\_c_ d
  64
  65 Execute (italic with escaped underscores):
  66   AssertNotEqual SyntaxOf('a'), 'htmlItalic'
  67   AssertEqual SyntaxOf('b'), 'htmlItalic'
  68   AssertEqual SyntaxOf('c'), 'htmlItalic'
  69   AssertNotEqual SyntaxOf('d'), 'htmlItalic'
  70
  71 Given markdown;
  72 a_b_c
  73
  74 Execute (not italic underscores within text):
  75   AssertNotEqual SyntaxOf('a'), 'htmlItalic'
  76   AssertNotEqual SyntaxOf('b'), 'htmlItalic'
  77   AssertNotEqual SyntaxOf('c'), 'htmlItalic'
  78
  79 Given markdown;
  80 a *b\*c* d
  81
  82 Execute (italic with escaped asterisks):
  83   AssertNotEqual SyntaxOf('a'), 'htmlItalic'
  84   AssertEqual SyntaxOf('b'), 'htmlItalic'
  85   AssertEqual SyntaxOf('c'), 'htmlItalic'
  86   AssertNotEqual SyntaxOf('d'), 'htmlItalic'
  87
  88 Given markdown;
  89 a __b\_\_c__ d
  90
  91 Execute (bold with escaped underscores):
  92   AssertNotEqual SyntaxOf('a'), 'htmlBold'
  93   AssertEqual SyntaxOf('b'), 'htmlBold'
  94   AssertEqual SyntaxOf('c'), 'htmlBold'
  95   AssertNotEqual SyntaxOf('d'), 'htmlBold'
  96
  97 Given markdown;
  98 _a b
  99 c_ d
 100
 101 Execute (italic with underscores in multiple lines):
 102   AssertEqual SyntaxOf('a'), 'htmlItalic'
 103   AssertEqual SyntaxOf('b'), 'htmlItalic'
 104   AssertEqual SyntaxOf('c'), 'htmlItalic'
 105   AssertNotEqual SyntaxOf('d'), 'htmlItalic'
 106
 107 Given markdown;
 108 __a b
 109 c__ d
 110
 111 Execute (bold with underscores in multiple lines):
 112   AssertEqual SyntaxOf('a'), 'htmlBold'
 113   AssertEqual SyntaxOf('b'), 'htmlBold'
 114   AssertEqual SyntaxOf('c'), 'htmlBold'
 115   AssertNotEqual SyntaxOf('d'), 'htmlBold'
 116
 117 Given markdown;
 118 ___a b
 119 c___ d
 120
 121 Execute (bold italic with underscores in multiple lines):
 122   AssertEqual SyntaxOf('a'), 'htmlBoldItalic'
 123   AssertEqual SyntaxOf('b'), 'htmlBoldItalic'
 124   AssertEqual SyntaxOf('c'), 'htmlBoldItalic'
 125   AssertNotEqual SyntaxOf('d'), 'htmlBoldItalic'
 126
 127 Given markdown;
 128 *a b
 129 c* d
 130
 131 Execute (italic with asterisks in multiple lines):
 132   AssertEqual SyntaxOf('a'), 'htmlItalic'
 133   AssertEqual SyntaxOf('b'), 'htmlItalic'
 134   AssertEqual SyntaxOf('c'), 'htmlItalic'
 135   AssertNotEqual SyntaxOf('d'), 'htmlItalic'
 136
 137 Given markdown;
 138 **a b
 139 c** d
 140
 141 Execute (bold with asterisks in multiple lines):
 142   AssertEqual SyntaxOf('a'), 'htmlBold'
 143   AssertEqual SyntaxOf('b'), 'htmlBold'
 144   AssertEqual SyntaxOf('c'), 'htmlBold'
 145   AssertNotEqual SyntaxOf('d'), 'htmlBold'
 146
 147 Given markdown;
 148 ***a b
 149 c*** d
 150
 151 Execute (bold italic with asterisks in multiple lines):
 152   AssertEqual SyntaxOf('a'), 'htmlBoldItalic'
 153   AssertEqual SyntaxOf('b'), 'htmlBoldItalic'
 154   AssertEqual SyntaxOf('c'), 'htmlBoldItalic'
 155   AssertNotEqual SyntaxOf('d'), 'htmlBoldItalic'
 156
 157 Given markdown;
 158 *a
 159
 160 Execute (not italic with an asterisk):
 161   AssertNotEqual SyntaxOf('a'), 'htmlItalic'
 162
 163 Given markdown;
 164 [__](a) b
 165
 166 Execute (not bold with double underscores):
 167   AssertNotEqual SyntaxOf('_'), 'htmlBold'
 168   AssertNotEqual SyntaxOf('a'), 'htmlBold'
 169   AssertNotEqual SyntaxOf('b'), 'htmlBold'
 170
 171 Given markdown;
 172 _a_
 173
 174 Execute (conceal italic):
 175   if has('conceal')
 176     setlocal conceallevel=2
 177     AssertEqual synconcealed(1, 1)[0], 1
 178     AssertEqual synconcealed(1, 2)[0], 0
 179     AssertEqual synconcealed(1, 3)[0], 1
 180     setlocal conceallevel=0
 181   endif
 182
 183 Execute (disable conceal):
 184   if has('conceal')
 185     let g:vim_markdown_conceal=0
 186     syn off | syn on
 187     setlocal conceallevel=2
 188     AssertEqual synconcealed(1, 1)[0], 0
 189     AssertEqual synconcealed(1, 2)[0], 0
 190     AssertEqual synconcealed(1, 3)[0], 0
 191
 192     let g:vim_markdown_conceal=1
 193     syn off | syn on
 194     AssertEqual synconcealed(1, 1)[0], 1
 195     AssertEqual synconcealed(1, 2)[0], 0
 196     AssertEqual synconcealed(1, 3)[0], 1
 197
 198     setlocal conceallevel=0
 199     unlet g:vim_markdown_conceal
 200     syn off | syn on
 201   endif
 202
 203 Given markdown;
 204 *a*
 205
 206 Execute (conceal italic):
 207   if has('conceal')
 208     setlocal conceallevel=2
 209     AssertEqual synconcealed(1, 1)[0], 1
 210     AssertEqual synconcealed(1, 2)[0], 0
 211     AssertEqual synconcealed(1, 3)[0], 1
 212     setlocal conceallevel=0
 213   endif
 214
 215 Execute (disable conceal):
 216   if has('conceal')
 217     let g:vim_markdown_conceal=0
 218     syn off | syn on
 219     setlocal conceallevel=2
 220     AssertEqual synconcealed(1, 1)[0], 0
 221     AssertEqual synconcealed(1, 2)[0], 0
 222     AssertEqual synconcealed(1, 3)[0], 0
 223
 224     let g:vim_markdown_conceal=1
 225     syn off | syn on
 226     AssertEqual synconcealed(1, 1)[0], 1
 227     AssertEqual synconcealed(1, 2)[0], 0
 228     AssertEqual synconcealed(1, 3)[0], 1
 229
 230     setlocal conceallevel=0
 231     unlet g:vim_markdown_conceal
 232     syn off | syn on
 233   endif
 234
 235 Given markdown;
 236 __a__
 237
 238 Execute (conceal bold):
 239   if has('conceal')
 240     setlocal conceallevel=2
 241     AssertEqual synconcealed(1, 1)[0], 1
 242     AssertEqual synconcealed(1, 2)[0], 1
 243     AssertEqual synconcealed(1, 3)[0], 0
 244     AssertEqual synconcealed(1, 4)[0], 1
 245     AssertEqual synconcealed(1, 5)[0], 1
 246     setlocal conceallevel=0
 247   endif
 248
 249 Execute (disable conceal):
 250   if has('conceal')
 251     let g:vim_markdown_conceal=0
 252     syn off | syn on
 253     setlocal conceallevel=2
 254     AssertEqual synconcealed(1, 1)[0], 0
 255     AssertEqual synconcealed(1, 2)[0], 0
 256     AssertEqual synconcealed(1, 3)[0], 0
 257     AssertEqual synconcealed(1, 4)[0], 0
 258     AssertEqual synconcealed(1, 5)[0], 0
 259
 260     let g:vim_markdown_conceal=1
 261     syn off | syn on
 262     AssertEqual synconcealed(1, 1)[0], 1
 263     AssertEqual synconcealed(1, 2)[0], 1
 264     AssertEqual synconcealed(1, 3)[0], 0
 265     AssertEqual synconcealed(1, 4)[0], 1
 266     AssertEqual synconcealed(1, 5)[0], 1
 267
 268     setlocal conceallevel=0
 269     unlet g:vim_markdown_conceal
 270     syn off | syn on
 271   endif
 272
 273 Given markdown;
 274 **a**
 275
 276 Execute (conceal bold):
 277   if has('conceal')
 278     setlocal conceallevel=2
 279     AssertEqual synconcealed(1, 1)[0], 1
 280     AssertEqual synconcealed(1, 2)[0], 1
 281     AssertEqual synconcealed(1, 3)[0], 0
 282     AssertEqual synconcealed(1, 4)[0], 1
 283     AssertEqual synconcealed(1, 5)[0], 1
 284     setlocal conceallevel=0
 285   endif
 286
 287 Execute (disable conceal):
 288   if has('conceal')
 289     let g:vim_markdown_conceal=0
 290     syn off | syn on
 291     setlocal conceallevel=2
 292     AssertEqual synconcealed(1, 1)[0], 0
 293     AssertEqual synconcealed(1, 2)[0], 0
 294     AssertEqual synconcealed(1, 3)[0], 0
 295     AssertEqual synconcealed(1, 4)[0], 0
 296     AssertEqual synconcealed(1, 5)[0], 0
 297
 298     let g:vim_markdown_conceal=1
 299     syn off | syn on
 300     AssertEqual synconcealed(1, 1)[0], 1
 301     AssertEqual synconcealed(1, 2)[0], 1
 302     AssertEqual synconcealed(1, 3)[0], 0
 303     AssertEqual synconcealed(1, 4)[0], 1
 304     AssertEqual synconcealed(1, 5)[0], 1
 305
 306     setlocal conceallevel=0
 307     unlet g:vim_markdown_conceal
 308     syn off | syn on
 309   endif
 310
 311 Given markdown;
 312 ___a___
 313
 314 Execute (conceal italic bold):
 315   if has('conceal')
 316     setlocal conceallevel=2
 317     AssertEqual synconcealed(1, 1)[0], 1
 318     AssertEqual synconcealed(1, 2)[0], 1
 319     AssertEqual synconcealed(1, 3)[0], 1
 320     AssertEqual synconcealed(1, 4)[0], 0
 321     AssertEqual synconcealed(1, 5)[0], 1
 322     AssertEqual synconcealed(1, 6)[0], 1
 323     AssertEqual synconcealed(1, 7)[0], 1
 324     setlocal conceallevel=0
 325   endif
 326
 327 Execute (disable conceal):
 328   if has('conceal')
 329     let g:vim_markdown_conceal=0
 330     syn off | syn on
 331     setlocal conceallevel=2
 332     AssertEqual synconcealed(1, 1)[0], 0
 333     AssertEqual synconcealed(1, 2)[0], 0
 334     AssertEqual synconcealed(1, 3)[0], 0
 335     AssertEqual synconcealed(1, 4)[0], 0
 336     AssertEqual synconcealed(1, 5)[0], 0
 337     AssertEqual synconcealed(1, 6)[0], 0
 338     AssertEqual synconcealed(1, 7)[0], 0
 339
 340     let g:vim_markdown_conceal=1
 341     syn off | syn on
 342     AssertEqual synconcealed(1, 1)[0], 1
 343     AssertEqual synconcealed(1, 2)[0], 1
 344     AssertEqual synconcealed(1, 3)[0], 1
 345     AssertEqual synconcealed(1, 4)[0], 0
 346     AssertEqual synconcealed(1, 5)[0], 1
 347     AssertEqual synconcealed(1, 6)[0], 1
 348     AssertEqual synconcealed(1, 7)[0], 1
 349
 350     setlocal conceallevel=0
 351     unlet g:vim_markdown_conceal
 352     syn off | syn on
 353   endif
 354
 355 Given markdown;
 356 ***a***
 357
 358 Execute (conceal italic bold):
 359   if has('conceal')
 360     setlocal conceallevel=2
 361     AssertEqual synconcealed(1, 1)[0], 1
 362     AssertEqual synconcealed(1, 2)[0], 1
 363     AssertEqual synconcealed(1, 3)[0], 1
 364     AssertEqual synconcealed(1, 4)[0], 0
 365     AssertEqual synconcealed(1, 5)[0], 1
 366     AssertEqual synconcealed(1, 6)[0], 1
 367     AssertEqual synconcealed(1, 7)[0], 1
 368     setlocal conceallevel=0
 369   endif
 370
 371 Execute (disable conceal):
 372   if has('conceal')
 373     let g:vim_markdown_conceal=0
 374     syn off | syn on
 375     setlocal conceallevel=2
 376     AssertEqual synconcealed(1, 1)[0], 0
 377     AssertEqual synconcealed(1, 2)[0], 0
 378     AssertEqual synconcealed(1, 3)[0], 0
 379     AssertEqual synconcealed(1, 4)[0], 0
 380     AssertEqual synconcealed(1, 5)[0], 0
 381     AssertEqual synconcealed(1, 6)[0], 0
 382     AssertEqual synconcealed(1, 7)[0], 0
 383
 384     let g:vim_markdown_conceal=1
 385     syn off | syn on
 386     AssertEqual synconcealed(1, 1)[0], 1
 387     AssertEqual synconcealed(1, 2)[0], 1
 388     AssertEqual synconcealed(1, 3)[0], 1
 389     AssertEqual synconcealed(1, 4)[0], 0
 390     AssertEqual synconcealed(1, 5)[0], 1
 391     AssertEqual synconcealed(1, 6)[0], 1
 392     AssertEqual synconcealed(1, 7)[0], 1
 393
 394     setlocal conceallevel=0
 395     unlet g:vim_markdown_conceal
 396     syn off | syn on
 397   endif
 398
 399 # Links
 400
 401 Given markdown;
 402 [a](b)
 403
 404 Execute (link with title):
 405   AssertEqual SyntaxOf('a'), 'mkdLink'
 406   AssertEqual SyntaxOf('b'), 'mkdURL'
 407
 408 Given markdown;
 409 [a
 410 b](c)
 411
 412 Execute (link text with newline):
 413   AssertEqual SyntaxOf('a'), 'mkdLink'
 414   AssertEqual SyntaxOf('b'), 'mkdLink'
 415   AssertEqual SyntaxOf('c'), 'mkdURL'
 416
 417 Given markdown;
 418 [a] b [c](d)
 419
 420 Execute (link text with bracket sections):
 421   AssertNotEqual SyntaxOf('a'), 'mkdLink'
 422   AssertNotEqual SyntaxOf('b'), 'mkdLink'
 423   AssertEqual SyntaxOf('c'), 'mkdLink'
 424   AssertEqual SyntaxOf('d'), 'mkdURL'
 425
 426 Given markdown;
 427 [^a]: b
 428
 429 Execute (footnote is not link):
 430   AssertNotEqual SyntaxOf('a'), 'mkdLinkDef'
 431
 432 Given markdown;
 433 (a)
 434
 435 (b)
 436
 437 Execute (parenthesis not in link):
 438   AssertNotEqual SyntaxOf('a'), 'mkdURL'
 439   AssertNotEqual SyntaxOf('b'), 'mkdURL'
 440
 441 Given markdown;
 442 [a](b) c [d](e)
 443
 444 Execute (multiple links on a line):
 445   AssertNotEqual SyntaxOf('c'), 'mkdLink'
 446   AssertNotEqual SyntaxOf('c'), 'mkdURL'
 447
 448 Given markdown;
 449 [a] (b)
 450
 451 Execute (space is not allowed between link text and parenthesis):
 452   AssertNotEqual SyntaxOf('a'), 'mkdLink'
 453   AssertNotEqual SyntaxOf('b'), 'mkdURL'
 454
 455 Given markdown;
 456 [a](b)
 457
 458 Execute (conceal link):
 459   if has('conceal')
 460     setlocal conceallevel=2
 461     AssertEqual synconcealed(1, 1)[0], 1
 462     AssertEqual synconcealed(1, 2)[0], 0
 463     AssertEqual synconcealed(1, 3)[0], 1
 464     AssertEqual synconcealed(1, 4)[0], 1
 465     AssertEqual synconcealed(1, 4)[0], 1
 466     AssertEqual synconcealed(1, 5)[0], 1
 467     AssertEqual synconcealed(1, 6)[0], 1
 468     setlocal conceallevel=0
 469   endif
 470
 471 Execute (disable conceal):
 472   if has('conceal')
 473     let g:vim_markdown_conceal=0
 474     syn off | syn on
 475     setlocal conceallevel=2
 476     AssertEqual synconcealed(1, 1)[0], 0
 477     AssertEqual synconcealed(1, 2)[0], 0
 478     AssertEqual synconcealed(1, 3)[0], 0
 479     AssertEqual synconcealed(1, 4)[0], 0
 480     AssertEqual synconcealed(1, 4)[0], 0
 481     AssertEqual synconcealed(1, 5)[0], 0
 482     AssertEqual synconcealed(1, 6)[0], 0
 483
 484     let g:vim_markdown_conceal=1
 485     syn off | syn on
 486     AssertEqual synconcealed(1, 1)[0], 1
 487     AssertEqual synconcealed(1, 2)[0], 0
 488     AssertEqual synconcealed(1, 3)[0], 1
 489     AssertEqual synconcealed(1, 4)[0], 1
 490     AssertEqual synconcealed(1, 4)[0], 1
 491     AssertEqual synconcealed(1, 5)[0], 1
 492     AssertEqual synconcealed(1, 6)[0], 1
 493
 494     setlocal conceallevel=0
 495     unlet g:vim_markdown_conceal
 496     syn off | syn on
 497   endif
 498
 499 # Autolinks
 500
 501 Given markdown;
 502 a <http://b> c
 503
 504 Execute (autolink):
 505   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
 506   AssertEqual SyntaxOf('<'), 'mkdDelimiter'
 507   AssertEqual SyntaxOf('b'), 'mkdInlineURL'
 508   AssertEqual SyntaxOf('>'), 'mkdDelimiter'
 509   AssertNotEqual SyntaxOf('c'), 'mkdInlineURL'
 510
 511 Given markdown;
 512 http://12monkeys.foo
 513
 514 Execute (autolink with domain starting with a number):
 515   AssertEqual SyntaxOf('12monkeys'), 'mkdInlineURL'
 516
 517 Given markdown;
 518 <HtTp://a>
 519
 520 Execute (autolink with scheme case is insensitive):
 521   AssertEqual SyntaxOf('a'), 'mkdInlineURL'
 522
 523 Given markdown;
 524 <a>
 525
 526 Execute (autolink without scheme is not a link):
 527   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
 528
 529 Given markdown;
 530 < http://a >
 531 <http://b c>
 532 <http://d
 533 e>
 534
 535 Execute (autolink with space is not a link):
 536   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
 537   AssertNotEqual SyntaxOf('b'), 'mkdInlineURL'
 538   AssertNotEqual SyntaxOf('c'), 'mkdInlineURL'
 539   AssertNotEqual SyntaxOf('d'), 'mkdInlineURL'
 540   AssertNotEqual SyntaxOf('e'), 'mkdInlineURL'
 541
 542 Given markdown;
 543 \<http://a>
 544
 545 Execute (autolinks can be backslash escaped):
 546   AssertNotEqual SyntaxOf('<'), 'mkdDelimiter'
 547
 548 Given markdown;
 549 a (http://b.bb) c
 550
 551 Execute (autolink in parenthesis):
 552   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
 553   AssertEqual SyntaxOf('('), 'mkdDelimiter'
 554   AssertEqual SyntaxOf('b'), 'mkdInlineURL'
 555   AssertEqual SyntaxOf(')'), 'mkdDelimiter'
 556   AssertNotEqual SyntaxOf('c'), 'mkdInlineURL'
 557
 558 Given markdown;
 559 [![a](http://b)](http://c)
 560
 561 Execute (autolink in link text):
 562   AssertEqual SyntaxOf('!'), 'mkdDelimiter'
 563   AssertEqual SyntaxOf('a'), 'mkdLink'
 564   AssertEqual SyntaxOf('b'), 'mkdURL'
 565   AssertEqual SyntaxOf('c'), 'mkdURL'
 566
 567 Given markdown;
 568 # [h1link](url)
 569
 570 ## [h2link](url)
 571
 572 ### [h3link](url)
 573
 574 #### [h4link](url)
 575
 576 ##### [h5link](url)
 577
 578 ###### [h6link](url)
 579
 580 [h1link_b](url)
 581 ===============
 582
 583 [h2link_b](url)
 584 ---------------
 585
 586 Execute (link in headers):
 587   AssertEqual SyntaxOf('h1link'), 'mkdLink'
 588   AssertEqual SyntaxOf('h2link'), 'mkdLink'
 589   AssertEqual SyntaxOf('h3link'), 'mkdLink'
 590   AssertEqual SyntaxOf('h4link'), 'mkdLink'
 591   AssertEqual SyntaxOf('h5link'), 'mkdLink'
 592   AssertEqual SyntaxOf('h6link'), 'mkdLink'
 593   AssertEqual SyntaxOf('h1link_b'), 'mkdLink'
 594   AssertEqual SyntaxOf('h2link_b'), 'mkdLink'
 595
 596 Given markdown;
 597 # http://h1link.foo
 598
 599 ## http://h2link.foo
 600
 601 ### http://h3link.foo
 602
 603 #### http://h4link.foo
 604
 605 ##### http://h5link.foo
 606
 607 ###### http://h6link.foo
 608
 609 http://h1link_b.foo
 610 ===================
 611
 612 http://h2link_b.foo
 613 -------------------
 614
 615 Execute (inline url in headers):
 616   AssertEqual SyntaxOf('h1link'), 'mkdInlineURL'
 617   AssertEqual SyntaxOf('h2link'), 'mkdInlineURL'
 618   AssertEqual SyntaxOf('h3link'), 'mkdInlineURL'
 619   AssertEqual SyntaxOf('h4link'), 'mkdInlineURL'
 620   AssertEqual SyntaxOf('h5link'), 'mkdInlineURL'
 621   AssertEqual SyntaxOf('h6link'), 'mkdInlineURL'
 622   AssertEqual SyntaxOf('h1link_b'), 'mkdInlineURL'
 623   AssertEqual SyntaxOf('h2link_b'), 'mkdInlineURL'
 624
 625 Given markdown;
 626 > [a](b)
 627 > http://foo.bar
 628
 629 Execute (link in blockquote):
 630   AssertEqual SyntaxOf('a'), 'mkdLink'
 631   AssertEqual SyntaxOf('foo'), 'mkdInlineURL'
 632
 633 Given markdown;
 634 [https://domain.tld](https://domain.com) not_a_link
 635
 636 Execute (link with url title):
 637   AssertEqual SyntaxOf('https://domain.tld'), 'mkdInlineURL'
 638   AssertNotEqual SyntaxOf(']'), 'mkdInlineURL'
 639   AssertEqual SyntaxOf('https://domain.com'), 'mkdURL'
 640   AssertNotEqual SyntaxOf('not_a_link'), 'mkdInlineURL'
 641
 642 # Code Blocks
 643
 644 Given markdown;
 645 ~~~
 646 code
 647 ~~~
 648
 649 Execute (code blocks can be fenced with tildes):
 650   AssertEqual SyntaxOf('c'), 'mkdCode'
 651
 652 Given markdown;
 653 ~~~~
 654 code
 655 ~~~~~
 656
 657 Execute (code blocks can be fenced with tildes longer than 3):
 658   AssertEqual SyntaxOf('c'), 'mkdCode'
 659
 660 Given markdown;
 661 ````
 662 code
 663 `````
 664
 665 Execute (code blocks can be fenced with backticks longer than 3):
 666   AssertEqual SyntaxOf('c'), 'mkdCode'
 667
 668 Given markdown;
 669 ~~~ruby
 670 code
 671 ~~~
 672
 673 Execute (code blocks can have a language specifier):
 674   AssertEqual SyntaxOf('c'), 'mkdCode'
 675
 676 Given markdown;
 677 ```c++
 678 code
 679 ```
 680
 681 text
 682
 683 Execute (code blocks can be fenced with backticks and a language specifier):
 684   AssertEqual SyntaxOf('code'), 'mkdCode'
 685   AssertNotEqual SyntaxOf('text'), 'mkdCode'
 686
 687 # Indent Code Blocks
 688
 689 Given markdown;
 690 a
 691
 692     b
 693     c
 694
 695 Execute (indent code blocks):
 696   AssertNotEqual SyntaxOf('a'), 'mkdCode'
 697   AssertEqual SyntaxOf('b'), 'mkdCode'
 698   AssertEqual SyntaxOf('c'), 'mkdCode'
 699
 700 Given markdown;
 701 # a
 702
 703 b
 704
 705     c
 706
 707 Execute (indent code blocks after header):
 708   AssertNotEqual SyntaxOf('a'), 'mkdCode'
 709   AssertNotEqual SyntaxOf('b'), 'mkdCode'
 710   AssertEqual SyntaxOf('c'), 'mkdCode'
 711
 712 Given markdown;
 713 -   a
 714
 715     b
 716
 717         c
 718
 719 Execute (indent code blocks after list):
 720   AssertNotEqual SyntaxOf('a'), 'mkdCode'
 721   AssertNotEqual SyntaxOf('b'), 'mkdCode'
 722   AssertEqual SyntaxOf('c'), 'mkdCode'
 723
 724 Given markdown;
 725     a
 726     b
 727
 728 Execute (indent code block at beginning of file):
 729   AssertEqual SyntaxOf('a'), 'mkdCode'
 730   AssertEqual SyntaxOf('b'), 'mkdCode'
 731
 732 Given markdown;
 733 ```c++
 734 #include <iostream>
 735 code
 736 ```
 737
 738 ```ruby
 739 def a
 740 end
 741 ```
 742
 743 ```ruby {linenos=table,hl_lines=[8,"15-17"],linenostart=199}
 744 class b
 745 end
 746 ```
 747
 748 Execute (fenced code block syntax with a language specifier):
 749   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
 750   call b:func(0)
 751   AssertEqual SyntaxOf('include'), 'cInclude'
 752   AssertEqual SyntaxOf('code'), 'mkdSnippetCPP'
 753   AssertEqual SyntaxOf('def'), 'rubyDefine'
 754   AssertEqual SyntaxOf('class'), 'rubyClass'
 755
 756 Given markdown;
 757 ``` c++
 758 #include <iostream>
 759 code
 760 ```
 761
 762 ```  vim
 763 let g:a = 1
 764 ```
 765
 766 ```     ruby
 767 def a
 768 end
 769 ```
 770
 771 ```
 772 ruby
 773 class B
 774 end
 775 ```
 776
 777 Execute (fenced code block syntax with a language specifier after whitespace):
 778   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
 779   call b:func(0)
 780   AssertEqual SyntaxOf('include'), 'cInclude'
 781   AssertEqual SyntaxOf('code'), 'mkdSnippetCPP'
 782   AssertEqual SyntaxOf('g:a'), 'vimVar'
 783   AssertEqual SyntaxOf('def'), 'rubyDefine'
 784   AssertNotEqual SyntaxOf('class'), 'rubyClass'
 785
 786 Given markdown;
 787 ```vim
 788 let g:a = 1
 789 ```
 790
 791 ```viml
 792 let g:b = 1
 793 ```
 794
 795 Execute (fenced code block syntax with alias language specifier):
 796   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
 797   call b:func(0)
 798   AssertEqual SyntaxOf('g:a'), 'vimVar'
 799   AssertEqual SyntaxOf('g:b'), 'vimVar'
 800
 801 Given markdown;
 802 ```csharp
 803 var s = "foo";
 804 ```
 805
 806 Execute (fenced code block languages setting):
 807   let g:vim_markdown_fenced_languages = ['csharp=cs']
 808   source ../ftplugin/markdown.vim
 809   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
 810   call b:func(0)
 811   AssertEqual SyntaxOf('foo'), 'csString'
 812   unlet g:vim_markdown_fenced_languages
 813
 814 Given markdown;
 815 ```vim
 816 let g:a = 1
 817 ```
 818
 819 Execute (fenced code block includes language syntax with reopening same buffer):
 820   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
 821   call b:func(0)
 822   split
 823   quit
 824   edit
 825   set filetype=markdown
 826   execute "normal! i```vim\<cr>let g:a = 1\<cr>```"
 827   call b:func(1)
 828   AssertEqual SyntaxOf('g:a'), 'vimVar'
 829
 830 Given markdown;
 831 ```a+b-
 832 code
 833 ```
 834
 835 Execute (fenced code block syntax with an unknown language specifier):
 836   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
 837   call b:func(0)
 838   AssertEqual SyntaxOf('code'), 'mkdSnippetA_B_'
 839
 840 Given markdown;
 841 ```
 842 =
 843 a
 844 -
 845 ```
 846
 847 Execute (first = or - in fenced code block is not setex headers):
 848   AssertEqual SyntaxOf('='), 'mkdCode'
 849   AssertEqual SyntaxOf('-'), 'mkdCode'
 850
 851 Given markdown;
 852 ``` {style=""}
 853 a
 854 ```
 855
 856 Execute (fenced code block with extended info strings):
 857   AssertEqual SyntaxOf('a'), 'mkdCode'
 858
 859 Given liquid;
 860 ```vim
 861 let g:a = 1
 862 ```
 863
 864 Execute (fenced code block syntax in liquid file with markdown subtype):
 865   let b:liquid_subtype = 'markdown'
 866   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
 867   call b:func(0)
 868   AssertEqual SyntaxOf('g:a'), 'vimVar'
 869
 870 # Code Blocks in pre and code tag
 871
 872 Given markdown;
 873 <pre>
 874 a
 875 </pre>
 876
 877 Execute (code block in pre tag):
 878   AssertEqual SyntaxOf('a'), 'mkdCode'
 879
 880 Given markdown;
 881 <code>
 882 a
 883 </code>
 884
 885 Execute (code block in code tag):
 886   AssertEqual SyntaxOf('a'), 'mkdCode'
 887
 888 Given markdown;
 889 \<pre\>
 890 a
 891 \</pre\>
 892
 893 Execute (not code block in escaped pre tag):
 894   AssertNotEqual SyntaxOf('a'), 'mkdCode'
 895
 896 Given markdown;
 897 \<code\>
 898 a
 899 \</code\>
 900
 901 Execute (not code block in escaped code tag):
 902   AssertNotEqual SyntaxOf('a'), 'mkdCode'
 903
 904 # Code quotes
 905
 906 Given markdown;
 907 `a`
 908
 909 Execute (code in code quotes):
 910   AssertEqual SyntaxOf('a'), 'mkdCode'
 911
 912 Given markdown;
 913 `a\` b `c\` d
 914
 915 Execute (code quotes not escaped ending with backslash):
 916   AssertEqual SyntaxOf('a\'), 'mkdCode'
 917   AssertNotEqual SyntaxOf('b'), 'mkdCode'
 918   AssertEqual SyntaxOf('c\'), 'mkdCode'
 919   AssertNotEqual SyntaxOf('d'), 'mkdCode'
 920
 921 Given markdown;
 922 ``a\`` b ``c`\`1`` d
 923
 924 Execute (double code quotes not escaped ending with backslash):
 925   AssertEqual SyntaxOf('a\'), 'mkdCode'
 926   AssertNotEqual SyntaxOf('b'), 'mkdCode'
 927   AssertEqual SyntaxOf('c`\\`1'), 'mkdCode'
 928   AssertNotEqual SyntaxOf('d'), 'mkdCode'
 929
 930 # Math
 931
 932 Given markdown;
 933 a $x$ b
 934 c $$y$$ d
 935 \$e\$
 936 \$\$f\$\$
 937
 938 Execute (math):
 939   AssertNotEqual SyntaxOf('x')[0:2], 'tex'
 940   AssertNotEqual SyntaxOf('y')[0:2], 'tex'
 941   let g:vim_markdown_math=1
 942   syn off | syn on
 943   AssertNotEqual SyntaxOf('a')[0:2], 'tex'
 944   AssertNotEqual SyntaxOf('b')[0:2], 'tex'
 945   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
 946   AssertNotEqual SyntaxOf('d')[0:2], 'tex'
 947   AssertNotEqual SyntaxOf('e')[0:2], 'tex'
 948   AssertNotEqual SyntaxOf('f')[0:2], 'tex'
 949   AssertEqual SyntaxOf('x')[0:2], 'tex'
 950   AssertEqual SyntaxOf('y')[0:2], 'tex'
 951   let g:vim_markdown_math=0
 952   syn off | syn on
 953   AssertNotEqual SyntaxOf('x')[0:2], 'tex'
 954   AssertNotEqual SyntaxOf('y')[0:2], 'tex'
 955
 956 Given markdown;
 957 a
 958
 959 $
 960 b
 961 $
 962
 963 c
 964
 965 Execute (multiline math):
 966   let g:vim_markdown_math=1
 967   syn off | syn on
 968   AssertNotEqual SyntaxOf('a')[0:2], 'tex'
 969   AssertEqual SyntaxOf('b')[0:2], 'tex'
 970   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
 971
 972 Given markdown;
 973 $ \sqrt{a}{b} $
 974 $$ \frac{a}{b} $$
 975
 976 Execute (math tex highlighting):
 977   let g:vim_markdown_math=0
 978   syn off | syn on
 979   AssertNotEqual SyntaxOf('sqrt')[0:2], 'tex'
 980   AssertNotEqual SyntaxOf('frac')[0:2], 'tex'
 981   let g:vim_markdown_math=1
 982   syn off | syn on
 983   AssertEqual SyntaxOf('sqrt')[0:2], 'tex'
 984   AssertEqual SyntaxOf('frac')[0:2], 'tex'
 985
 986 Given markdown;
 987 $a b[$ c
 988
 989 Execute (math ends with $):
 990   let g:vim_markdown_math=1
 991   syn off | syn on
 992   AssertEqual SyntaxOf('a')[0:2], 'tex'
 993   AssertEqual SyntaxOf('b')[0:2], 'tex'
 994   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
 995
 996 Given markdown;
 997 $$a b[$$ c
 998
 999 Execute (math ends with $$):
1000   let g:vim_markdown_math=1
1001   syn off | syn on
1002   AssertEqual SyntaxOf('a')[0:2], 'tex'
1003   AssertEqual SyntaxOf('b')[0:2], 'tex'
1004   AssertNotEqual SyntaxOf('c')[0:2], 'tex'
1005
1006 Given markdown;
1007 $(0 \leq 1)$
1008
1009 Execute (math conceal in $):
1010   if has('conceal')
1011     setlocal conceallevel=2
1012     let g:vim_markdown_math=1
1013     syn off | syn on
1014     AssertEqual synconcealed(1, 1)[0], 1, '$'
1015     AssertEqual synconcealed(1, 2)[0], 0
1016     AssertEqual synconcealed(1, 3)[0], 0
1017     AssertEqual synconcealed(1, 4)[0], 0
1018     AssertEqual synconcealed(1, 5)[0], 1, '\leq'
1019     AssertEqual synconcealed(1, 6)[0], 1
1020     AssertEqual synconcealed(1, 7)[0], 1
1021     AssertEqual synconcealed(1, 8)[0], 1
1022     AssertEqual synconcealed(1, 9)[0], 0
1023     AssertEqual synconcealed(1, 10)[0], 0
1024     AssertEqual synconcealed(1, 11)[0], 0
1025     AssertEqual synconcealed(1, 12)[0], 1, '$'
1026     setlocal conceallevel=0
1027   endif
1028
1029 Given markdown;
1030 $$
1031 \omega
1032 0 \leq 1
1033 $$
1034
1035 Execute (math conceal in $$):
1036   if has('conceal')
1037     setlocal conceallevel=2
1038     let g:vim_markdown_math=1
1039     syn off | syn on
1040     AssertEqual synconcealed(1, 1)[0], 1, '$$'
1041     AssertEqual synconcealed(2, 1)[0], 1, '\omega'
1042     AssertEqual synconcealed(3, 1)[0], 0, '0'
1043     AssertEqual synconcealed(3, 3)[0], 1, '\leq'
1044     AssertEqual synconcealed(3, 8)[0], 0, '1'
1045     AssertEqual synconcealed(4, 1)[0], 1, '$$'
1046     setlocal conceallevel=0
1047   endif
1048
1049 # YAML frontmatter
1050
1051 Given markdown;
1052 ---
1053 a: b
1054 ---
1055
1056 Execute (YAML frontmatter is controlled by the option):
1057   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
1058   let g:vim_markdown_frontmatter=1
1059   syn off | syn on
1060   AssertEqual SyntaxOf('a')[0:3], 'yaml'
1061   let g:vim_markdown_frontmatter=0
1062   syn off | syn on
1063   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
1064
1065 Given markdown;
1066
1067 ---
1068 a: b
1069 ---
1070
1071 Execute (YAML frontmatter only works if it's the first thing in the file):
1072   let g:vim_markdown_frontmatter=1
1073   syn off | syn on
1074   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
1075
1076 Given markdown;
1077 ---
1078 a: b
1079 ---
1080
1081 ---
1082
1083 Execute (rules are not mistaken by YAML frontmatter delimiters):
1084   let g:vim_markdown_frontmatter=1
1085   syn off | syn on
1086   AssertEqual SyntaxAt(5, 1), 'mkdRule'
1087   unlet g:vim_markdown_frontmatter
1088
1089 # TOML frontmatter
1090
1091 Given markdown;
1092 +++
1093 a = "b"
1094 +++
1095
1096 Execute (TOML frontmatter is controlled by the option):
1097   syn off | syn on
1098   AssertNotEqual SyntaxOf('b'), 'tomlString'
1099   let g:vim_markdown_toml_frontmatter=1
1100   syn off | syn on
1101   AssertEqual SyntaxOf('b'), 'tomlString'
1102   let g:vim_markdown_toml_frontmatter=0
1103   syn off | syn on
1104   AssertNotEqual SyntaxOf('b'), 'tomlString'
1105
1106 Given markdown;
1107
1108 +++
1109 a = "b"
1110 +++
1111
1112 Execute (TOML frontmatter only works if it's the first thing in the file):
1113   let g:vim_markdown_toml_frontmatter=1
1114   syn off | syn on
1115   AssertNotEqual SyntaxOf('b'), 'tomlString'
1116   unlet g:vim_markdown_toml_frontmatter
1117
1118 # JSON frontmatter
1119
1120 Given markdown;
1121 {
1122   "a": "b"
1123 }
1124
1125 Execute (JSON frontmatter is controlled by the option):
1126   syn off | syn on
1127   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
1128   let g:vim_markdown_json_frontmatter=1
1129   syn off | syn on
1130   AssertEqual SyntaxOf('a'), 'jsonKeyword'
1131   let g:vim_markdown_json_frontmatter=0
1132   syn off | syn on
1133   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
1134
1135 Given markdown;
1136
1137 {
1138   "a": "b"
1139 }
1140
1141 Execute (JSON frontmatter only works if it's the first thing in the file):
1142   let g:vim_markdown_json_frontmatter=1
1143   syn off | syn on
1144   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
1145   unlet g:vim_markdown_json_frontmatter
1146
1147 # Header
1148
1149 Given markdown;
1150 # #a
1151 ccc
1152
1153 ## #b
1154 ddd
1155
1156 Execute (header title starts with #):
1157   AssertEqual SyntaxOf('a'), 'htmlH1'
1158   AssertEqual SyntaxOf('b'), 'htmlH2'
1159
1160 Given markdown;
1161 # h1 space
1162
1163 #h1 nospace
1164
1165 #  h1 2 spaces
1166
1167 # h1 trailing hash #
1168
1169 ## h2 space
1170
1171 ##h2 nospace
1172
1173 ## h2 trailing hash ##
1174
1175 ### h3 space
1176
1177 ###h3 nospace
1178
1179 ### h3 trailing hash ###
1180
1181 #### h4
1182
1183 ##### h5
1184
1185 ###### h6
1186
1187 Execute (atx headers):
1188   AssertEqual SyntaxOf(' h1 space'), 'htmlH1'
1189   AssertEqual SyntaxOf('h1 nospace'), 'htmlH1'
1190   AssertEqual SyntaxOf('  h1 2 spaces'), 'htmlH1'
1191   AssertEqual SyntaxOf(' h1 trailing hash '), 'htmlH1'
1192   AssertEqual SyntaxOf(' h2 space'), 'htmlH2'
1193   AssertEqual SyntaxOf('h2 nospace'), 'htmlH2'
1194   AssertEqual SyntaxOf(' h2 trailing hash '), 'htmlH2'
1195   AssertEqual SyntaxOf(' h3 space'), 'htmlH3'
1196   AssertEqual SyntaxOf('h3 nospace'), 'htmlH3'
1197   AssertEqual SyntaxOf(' h3 trailing hash '), 'htmlH3'
1198   AssertEqual SyntaxOf(' h4'), 'htmlH4'
1199   AssertEqual SyntaxOf(' h5'), 'htmlH5'
1200   AssertEqual SyntaxOf(' h6'), 'htmlH6'
1201
1202 Given markdown;
1203 # h1 before h2
1204
1205 ## h2 between h1s
1206
1207 # h1 after h2
1208
1209 Execute (atx headers relative positions):
1210   AssertEqual SyntaxOf(' h1 before h2'), 'htmlH1'
1211   AssertEqual SyntaxOf(' h2 between h1s'), 'htmlH2'
1212   AssertEqual SyntaxOf(' h1 after h2'), 'htmlH1'
1213
1214 Given markdown;
1215 setex h1
1216 ========
1217
1218 setex h2
1219 --------
1220
1221 setex h1 single punctuation
1222 =
1223
1224 setex h1 punctuation longer than header
1225 ================================
1226
1227 Execute (setex headers):
1228   AssertEqual SyntaxOf('setex h1'), 'htmlH1'
1229   AssertEqual SyntaxOf('^========$'), 'htmlH1'
1230   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
1231   AssertEqual SyntaxOf('--------'), 'htmlH2'
1232   AssertEqual SyntaxOf('setex h1 single punctuation'), 'htmlH1'
1233   AssertEqual SyntaxOf('^=$'), 'htmlH1'
1234   AssertEqual SyntaxOf('setex h1 punctuation longer than header'), 'htmlH1'
1235   AssertEqual SyntaxOf('^================================$'), 'htmlH1'
1236
1237 Given markdown;
1238 - not Setex
1239 - because list
1240
1241 Execute (prevent list vs Setex confusion):
1242   AssertNotEqual SyntaxOf('- not Setex'), 'htmlH2'
1243   AssertNotEqual SyntaxOf('- becuase list'), 'htmlH2'
1244
1245 Given markdown;
1246 setex h1 before atx
1247 ===================
1248
1249 ## atx h2
1250
1251 ### atx h3
1252
1253 # atx h1
1254
1255 setex h2
1256 ------------------
1257
1258 ### atx h3 2
1259
1260 Execute (mixed atx and setex headers):
1261   AssertEqual SyntaxOf('setex h1 before atx'), 'htmlH1'
1262   AssertEqual SyntaxOf('==================='), 'htmlH1'
1263   AssertEqual SyntaxOf(' atx h2'), 'htmlH2'
1264   AssertEqual SyntaxOf(' atx h3'), 'htmlH3'
1265   AssertEqual SyntaxOf(' atx h1'), 'htmlH1'
1266   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
1267   AssertEqual SyntaxOf('------------------'), 'htmlH2'
1268
1269 # List
1270
1271 Given markdown;
1272 - a & b
1273 1. c > d
1274
1275 Execute (& and > are not marked as htmlError in lists):
1276   AssertEqual SyntaxOf('-'), 'mkdListItem'
1277   AssertEqual SyntaxOf('1.'), 'mkdListItem'
1278   AssertNotEqual SyntaxOf('&'), 'htmlError'
1279   AssertNotEqual SyntaxOf('>'), 'htmlError'
1280
1281 Given markdown;
1282 1. a
1283 2. b
1284
1285 Execute (list after line break):
1286   AssertEqual SyntaxOf('1'), 'mkdListItem'
1287   AssertEqual SyntaxOf('2'), 'mkdListItem'
1288
1289 # HTML
1290
1291 Given markdown;
1292 a
1293
1294 <p>b</p>
1295
1296 - <span>c</span>
1297
1298 Execute (HTML tag in text):
1299   AssertEqual SyntaxOf('p'), 'htmlTagName'
1300   AssertEqual SyntaxOf('<p>'), 'htmlTag'
1301   AssertEqual SyntaxOf('</p>'), 'htmlEndTag'
1302   AssertEqual SyntaxOf('span'), 'htmlTagName'
1303   AssertEqual SyntaxOf('<span>'), 'htmlTag'
1304   AssertEqual SyntaxOf('</span>'), 'htmlEndTag'
1305
1306 Given markdown;
1307 # _h1_
1308
1309 ## _h2_
1310
1311 ### _h3_
1312
1313 #### _h4_
1314
1315 ##### _h5_
1316
1317 ###### _h6_
1318
1319 Execute (underscore italic text in atx headings):
1320   AssertEqual SyntaxOf('h1'), 'htmlItalic'
1321   AssertEqual SyntaxOf('h2'), 'htmlItalic'
1322   AssertEqual SyntaxOf('h3'), 'htmlItalic'
1323   AssertEqual SyntaxOf('h4'), 'htmlItalic'
1324   AssertEqual SyntaxOf('h5'), 'htmlItalic'
1325   AssertEqual SyntaxOf('h6'), 'htmlItalic'
1326
1327 Given markdown;
1328 # *h1*
1329
1330 ## *h2*
1331
1332 ### *h3*
1333
1334 #### *h4*
1335
1336 ##### *h5*
1337
1338 ###### *h6*
1339
1340 Execute (asterisk italic text in atx headings):
1341   AssertEqual SyntaxOf('h1'), 'htmlItalic'
1342   AssertEqual SyntaxOf('h2'), 'htmlItalic'
1343   AssertEqual SyntaxOf('h3'), 'htmlItalic'
1344   AssertEqual SyntaxOf('h4'), 'htmlItalic'
1345   AssertEqual SyntaxOf('h5'), 'htmlItalic'
1346   AssertEqual SyntaxOf('h6'), 'htmlItalic'
1347
1348 Given markdown;
1349 _h1_
1350 =
1351
1352 _h2_
1353 -
1354
1355 Execute (underscore italic text in setext headings):
1356   AssertEqual SyntaxOf('h1'), 'htmlItalic'
1357   AssertEqual SyntaxOf('h2'), 'htmlItalic'
1358
1359 Given markdown;
1360 *h1*
1361 =
1362
1363 *h2*
1364 -
1365
1366 Execute (asterisk italic text in setext headings):
1367   AssertEqual SyntaxOf('h1'), 'htmlItalic'
1368   AssertEqual SyntaxOf('h2'), 'htmlItalic'
1369
1370 Given markdown;
1371 # __h1__
1372
1373 ## __h2__
1374
1375 ### __h3__
1376
1377 #### __h4__
1378
1379 ##### __h5__
1380
1381 ###### __h6__
1382
1383 Execute (underscore bold text in atx headings):
1384   AssertEqual SyntaxOf('h1'), 'htmlBold'
1385   AssertEqual SyntaxOf('h2'), 'htmlBold'
1386   AssertEqual SyntaxOf('h3'), 'htmlBold'
1387   AssertEqual SyntaxOf('h4'), 'htmlBold'
1388   AssertEqual SyntaxOf('h5'), 'htmlBold'
1389   AssertEqual SyntaxOf('h6'), 'htmlBold'
1390
1391 Given markdown;
1392 # **h1**
1393
1394 ## **h2**
1395
1396 ### **h3**
1397
1398 #### **h4**
1399
1400 ##### **h5**
1401
1402 ###### **h6**
1403
1404 Execute (asterisk bold text in atx headings):
1405   AssertEqual SyntaxOf('h1'), 'htmlBold'
1406   AssertEqual SyntaxOf('h2'), 'htmlBold'
1407   AssertEqual SyntaxOf('h3'), 'htmlBold'
1408   AssertEqual SyntaxOf('h4'), 'htmlBold'
1409   AssertEqual SyntaxOf('h5'), 'htmlBold'
1410   AssertEqual SyntaxOf('h6'), 'htmlBold'
1411
1412 Given markdown;
1413 __h1__
1414 =
1415
1416 __h2__
1417 -
1418
1419 Execute (underscore bold text in setext headings):
1420   AssertEqual SyntaxOf('h1'), 'htmlBold'
1421   AssertEqual SyntaxOf('h2'), 'htmlBold'
1422
1423 Given markdown;
1424 **h1**
1425 =
1426
1427 **h2**
1428 -
1429
1430 Execute (asterisk bold text in setext headings):
1431   AssertEqual SyntaxOf('h1'), 'htmlBold'
1432   AssertEqual SyntaxOf('h2'), 'htmlBold'
1433
1434 Given markdown;
1435 # ___h1___
1436
1437 ## ___h2___
1438
1439 ### ___h3___
1440
1441 #### ___h4___
1442
1443 ##### ___h5___
1444
1445 ###### ___h6___
1446
1447 Execute (underscore bold italic text in atx headings):
1448   AssertEqual SyntaxOf('h1'), 'htmlBoldItalic'
1449   AssertEqual SyntaxOf('h2'), 'htmlBoldItalic'
1450   AssertEqual SyntaxOf('h3'), 'htmlBoldItalic'
1451   AssertEqual SyntaxOf('h4'), 'htmlBoldItalic'
1452   AssertEqual SyntaxOf('h5'), 'htmlBoldItalic'
1453   AssertEqual SyntaxOf('h6'), 'htmlBoldItalic'
1454
1455 Given markdown;
1456 # ***h1***
1457
1458 ## ***h2***
1459
1460 ### ***h3***
1461
1462 #### ***h4***
1463
1464 ##### ***h5***
1465
1466 ###### ***h6***
1467
1468 Execute (asterisk bold italic text in atx headings):
1469   AssertEqual SyntaxOf('h1'), 'htmlBoldItalic'
1470   AssertEqual SyntaxOf('h2'), 'htmlBoldItalic'
1471   AssertEqual SyntaxOf('h3'), 'htmlBoldItalic'
1472   AssertEqual SyntaxOf('h4'), 'htmlBoldItalic'
1473   AssertEqual SyntaxOf('h5'), 'htmlBoldItalic'
1474   AssertEqual SyntaxOf('h6'), 'htmlBoldItalic'
1475
1476 Given markdown;
1477 ___h1___
1478 =
1479
1480 ___h2___
1481 -
1482
1483 Execute (underscore bold italic text in setext headings):
1484   AssertEqual SyntaxOf('h1'), 'htmlBoldItalic'
1485   AssertEqual SyntaxOf('h2'), 'htmlBoldItalic'
1486
1487 Given markdown;
1488 ***h1***
1489 =
1490
1491 ***h2***
1492 -
1493
1494 Execute (asterisk bold italic text in setext headings):
1495   AssertEqual SyntaxOf('h1'), 'htmlBoldItalic'
1496   AssertEqual SyntaxOf('h2'), 'htmlBoldItalic'
1497
1498 Given markdown;
1499 # [^h1]
1500
1501 ## [^h2]
1502
1503 ### [^h3]
1504
1505 #### [^h4]
1506
1507 ##### [^h5]
1508
1509 ###### [^h6]
1510
1511 Execute (footnotes in atx headings):
1512   AssertEqual SyntaxOf('h1'), 'mkdFootnotes'
1513   AssertEqual SyntaxOf('h2'), 'mkdFootnotes'
1514   AssertEqual SyntaxOf('h3'), 'mkdFootnotes'
1515   AssertEqual SyntaxOf('h4'), 'mkdFootnotes'
1516   AssertEqual SyntaxOf('h5'), 'mkdFootnotes'
1517   AssertEqual SyntaxOf('h6'), 'mkdFootnotes'
1518
1519 Given markdown;
1520 [^h1]
1521 =
1522
1523 [^h2]
1524 -
1525
1526 Execute (footnotes in setext headings):
1527   AssertEqual SyntaxOf('h1'), 'mkdFootnotes'
1528   AssertEqual SyntaxOf('h2'), 'mkdFootnotes'