test/syntax.vader

   1 Given markdown;
   2 a **b** c
   3
   4 Execute (bold):
   5   AssertNotEqual SyntaxOf('a'), 'htmlBold'
   6   AssertEqual SyntaxOf('b'), 'htmlBold'
   7   AssertNotEqual SyntaxOf('c'), 'htmlBold'
   8
   9 Given markdown;
  10 a __b__ c
  11
  12 Execute (bold):
  13   AssertNotEqual SyntaxOf('a'), 'htmlBold'
  14   AssertEqual SyntaxOf('b'), 'htmlBold'
  15   AssertNotEqual SyntaxOf('c'), 'htmlBold'
  16
  17 Given markdown;
  18 a *b* c
  19
  20 Execute (italic):
  21   AssertNotEqual SyntaxOf('a'), 'htmlItalic'
  22   AssertEqual SyntaxOf('b'), 'htmlItalic'
  23   AssertNotEqual SyntaxOf('c'), 'htmlItalic'
  24
  25 Given markdown;
  26 a _b_ c
  27
  28 Execute (italic):
  29   AssertNotEqual SyntaxOf('a'), 'htmlItalic'
  30   AssertEqual SyntaxOf('b'), 'htmlItalic'
  31   AssertNotEqual SyntaxOf('c'), 'htmlItalic'
  32
  33 Given markdown;
  34 _a_b_
  35
  36 Execute (italic text has underscores):
  37   AssertEqual SyntaxOf('a'), 'htmlItalic'
  38   AssertEqual SyntaxOf('b'), 'htmlItalic'
  39
  40 Given markdown;
  41 a \*b\* c
  42
  43 Execute (not italic with escaped asterisks):
  44   AssertNotEqual SyntaxOf('a'), 'htmlItalic'
  45   AssertNotEqual SyntaxOf('b'), 'htmlItalic'
  46   AssertNotEqual SyntaxOf('c'), 'htmlItalic'
  47
  48 Given markdown;
  49 a \_b\_ c
  50
  51 Execute (not italic with escaped underscores):
  52   AssertNotEqual SyntaxOf('a'), 'htmlItalic'
  53   AssertNotEqual SyntaxOf('b'), 'htmlItalic'
  54   AssertNotEqual SyntaxOf('c'), 'htmlItalic'
  55
  56 Given markdown;
  57 a _b\_c_ d
  58
  59 Execute (italic with escaped underscores):
  60   AssertNotEqual SyntaxOf('a'), 'htmlItalic'
  61   AssertEqual SyntaxOf('b'), 'htmlItalic'
  62   AssertEqual SyntaxOf('c'), 'htmlItalic'
  63   AssertNotEqual SyntaxOf('d'), 'htmlItalic'
  64
  65 Given markdown;
  66 a_b_c
  67
  68 Execute (not italic underscores within text):
  69   AssertNotEqual SyntaxOf('a'), 'htmlItalic'
  70   AssertNotEqual SyntaxOf('b'), 'htmlItalic'
  71   AssertNotEqual SyntaxOf('c'), 'htmlItalic'
  72
  73 Given markdown;
  74 a *b\*c* d
  75
  76 Execute (italic with escaped asterisks):
  77   AssertNotEqual SyntaxOf('a'), 'htmlItalic'
  78   AssertEqual SyntaxOf('b'), 'htmlItalic'
  79   AssertEqual SyntaxOf('c'), 'htmlItalic'
  80   AssertNotEqual SyntaxOf('d'), 'htmlItalic'
  81
  82 Given markdown;
  83 a __b\_\_c__ d
  84
  85 Execute (bold with escaped underscores):
  86   AssertNotEqual SyntaxOf('a'), 'htmlBold'
  87   AssertEqual SyntaxOf('b'), 'htmlBold'
  88   AssertEqual SyntaxOf('c'), 'htmlBold'
  89   AssertNotEqual SyntaxOf('d'), 'htmlBold'
  90
  91 Given markdown;
  92 _a b
  93 c_ d
  94
  95 Execute (italic with underscores in multiple lines):
  96   AssertEqual SyntaxOf('a'), 'htmlItalic'
  97   AssertEqual SyntaxOf('b'), 'htmlItalic'
  98   AssertEqual SyntaxOf('c'), 'htmlItalic'
  99   AssertNotEqual SyntaxOf('d'), 'htmlItalic'
 100
 101 Given markdown;
 102 __a b
 103 c__ d
 104
 105 Execute (bold with underscores in multiple lines):
 106   AssertEqual SyntaxOf('a'), 'htmlBold'
 107   AssertEqual SyntaxOf('b'), 'htmlBold'
 108   AssertEqual SyntaxOf('c'), 'htmlBold'
 109   AssertNotEqual SyntaxOf('d'), 'htmlBold'
 110
 111 Given markdown;
 112 ___a b
 113 c___ d
 114
 115 Execute (bold italic with underscores in multiple lines):
 116   AssertEqual SyntaxOf('a'), 'htmlBoldItalic'
 117   AssertEqual SyntaxOf('b'), 'htmlBoldItalic'
 118   AssertEqual SyntaxOf('c'), 'htmlBoldItalic'
 119   AssertNotEqual SyntaxOf('d'), 'htmlBoldItalic'
 120
 121 Given markdown;
 122 *a b
 123 c* d
 124
 125 Execute (italic with asterisks in multiple lines):
 126   AssertEqual SyntaxOf('a'), 'htmlItalic'
 127   AssertEqual SyntaxOf('b'), 'htmlItalic'
 128   AssertEqual SyntaxOf('c'), 'htmlItalic'
 129   AssertNotEqual SyntaxOf('d'), 'htmlItalic'
 130
 131 Given markdown;
 132 **a b
 133 c** d
 134
 135 Execute (bold with asterisks in multiple lines):
 136   AssertEqual SyntaxOf('a'), 'htmlBold'
 137   AssertEqual SyntaxOf('b'), 'htmlBold'
 138   AssertEqual SyntaxOf('c'), 'htmlBold'
 139   AssertNotEqual SyntaxOf('d'), 'htmlBold'
 140
 141 Given markdown;
 142 ***a b
 143 c*** d
 144
 145 Execute (bold italic with asterisks in multiple lines):
 146   AssertEqual SyntaxOf('a'), 'htmlBoldItalic'
 147   AssertEqual SyntaxOf('b'), 'htmlBoldItalic'
 148   AssertEqual SyntaxOf('c'), 'htmlBoldItalic'
 149   AssertNotEqual SyntaxOf('d'), 'htmlBoldItalic'
 150
 151 # Links
 152
 153 Given markdown;
 154 [a](b)
 155
 156 Execute (link with title):
 157   AssertEqual SyntaxOf('a'), 'mkdLink'
 158   AssertEqual SyntaxOf('b'), 'mkdURL'
 159
 160 Given markdown;
 161 (a)
 162
 163 (b)
 164
 165 Execute (parenthesis not in link):
 166   AssertNotEqual SyntaxOf('a'), 'mkdURL'
 167   AssertNotEqual SyntaxOf('b'), 'mkdURL'
 168
 169 Given markdown;
 170 [a](b) c [d](e)
 171
 172 Execute (multiple links on a line):
 173   AssertNotEqual SyntaxOf('c'), 'mkdLink'
 174   AssertNotEqual SyntaxOf('c'), 'mkdURL'
 175
 176 Given markdown;
 177 [a] (b)
 178
 179 Execute (space is not allowed between link text and parenthesis):
 180   AssertNotEqual SyntaxOf('a'), 'mkdLink'
 181   AssertNotEqual SyntaxOf('b'), 'mkdURL'
 182
 183 Given markdown;
 184 [a](b)
 185
 186 Execute (conceal link):
 187   setlocal conceallevel=2
 188   AssertEqual synconcealed(1, 1)[0], 1
 189   AssertEqual synconcealed(1, 2)[0], 0
 190   AssertEqual synconcealed(1, 3)[0], 1
 191   AssertEqual synconcealed(1, 4)[0], 1
 192   AssertEqual synconcealed(1, 4)[0], 1
 193   AssertEqual synconcealed(1, 5)[0], 1
 194   AssertEqual synconcealed(1, 6)[0], 1
 195   setlocal conceallevel=0
 196
 197 # Autolinks
 198
 199 Given markdown;
 200 a <http://b> c
 201
 202 Execute (autolink):
 203   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
 204   AssertEqual SyntaxOf('<'), 'mkdDelimiter'
 205   AssertEqual SyntaxOf('b'), 'mkdInlineURL'
 206   AssertEqual SyntaxOf('>'), 'mkdDelimiter'
 207   AssertNotEqual SyntaxOf('c'), 'mkdInlineURL'
 208
 209 Given markdown;
 210 <HtTp://a>
 211
 212 Execute (autolink with scheme case is insensitive):
 213   AssertEqual SyntaxOf('a'), 'mkdInlineURL'
 214
 215 Given markdown;
 216 <a>
 217
 218 Execute (autolink without scheme is not a link):
 219   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
 220
 221 Given markdown;
 222 < http://a >
 223 <http://b c>
 224 <http://d
 225 e>
 226
 227 Execute (autolink with space is not a link):
 228   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
 229   AssertNotEqual SyntaxOf('b'), 'mkdInlineURL'
 230   AssertNotEqual SyntaxOf('c'), 'mkdInlineURL'
 231   AssertNotEqual SyntaxOf('d'), 'mkdInlineURL'
 232   AssertNotEqual SyntaxOf('e'), 'mkdInlineURL'
 233
 234 Given markdown;
 235 \<http://a>
 236
 237 Execute (autolinks can be backslash escaped):
 238   AssertNotEqual SyntaxOf('<'), 'mkdDelimiter'
 239
 240 Given markdown;
 241 a (http://b.bb) c
 242
 243 Execute (autolink in parenthesis):
 244   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
 245   AssertEqual SyntaxOf('('), 'mkdDelimiter'
 246   AssertEqual SyntaxOf('b'), 'mkdInlineURL'
 247   AssertEqual SyntaxOf(')'), 'mkdDelimiter'
 248   AssertNotEqual SyntaxOf('c'), 'mkdInlineURL'
 249
 250 Given markdown;
 251 [![a](http://b)](http://c)
 252
 253 Execute (autolink in link text):
 254   AssertEqual SyntaxOf('!'), 'mkdDelimiter'
 255   AssertEqual SyntaxOf('a'), 'mkdLink'
 256   AssertEqual SyntaxOf('b'), 'mkdURL'
 257   AssertEqual SyntaxOf('c'), 'mkdURL'
 258
 259 # Code Blocks
 260
 261 Given markdown;
 262 ~~~
 263 code
 264 ~~~
 265
 266 Execute (code blocks can be fenced with tildes):
 267   AssertEqual SyntaxOf('c'), 'mkdCode'
 268
 269 Given markdown;
 270 ~~~~
 271 code
 272 ~~~~~
 273
 274 Execute (code blocks can be fenced with tildes longer than 3):
 275   AssertEqual SyntaxOf('c'), 'mkdCode'
 276
 277 Given markdown;
 278 ````
 279 code
 280 `````
 281
 282 Execute (code blocks can be fenced with backticks longer than 3):
 283   AssertEqual SyntaxOf('c'), 'mkdCode'
 284
 285 Given markdown;
 286 ~~~ruby
 287 code
 288 ~~~
 289
 290 Execute (code blocks can have a language specifier):
 291   AssertEqual SyntaxOf('c'), 'mkdCode'
 292
 293 Given markdown;
 294 ```c++
 295 code
 296 ```
 297
 298 text
 299
 300 Execute (code blocks can be fenced with backticks and a language specifier):
 301   AssertEqual SyntaxOf('code'), 'mkdCode'
 302   AssertNotEqual SyntaxOf('text'), 'mkdCode'
 303
 304 # Indent Code Blocks
 305
 306 Given markdown;
 307 a
 308
 309     b
 310     c
 311
 312 Execute (indent code blocks):
 313   AssertNotEqual SyntaxOf('a'), 'mkdCode'
 314   AssertEqual SyntaxOf('b'), 'mkdCode'
 315   AssertEqual SyntaxOf('c'), 'mkdCode'
 316
 317 Given markdown;
 318 # a
 319
 320 b
 321
 322     c
 323
 324 Execute (indent code blocks after header):
 325   AssertNotEqual SyntaxOf('a'), 'mkdCode'
 326   AssertNotEqual SyntaxOf('b'), 'mkdCode'
 327   AssertEqual SyntaxOf('c'), 'mkdCode'
 328
 329 Given markdown;
 330 -   a
 331
 332     b
 333
 334         c
 335
 336 Execute (indent code blocks after list):
 337   AssertNotEqual SyntaxOf('a'), 'mkdCode'
 338   AssertNotEqual SyntaxOf('b'), 'mkdCode'
 339   AssertEqual SyntaxOf('c'), 'mkdCode'
 340
 341 Given markdown;
 342     a
 343     b
 344
 345 Execute (indent code block at beginning of file):
 346   AssertEqual SyntaxOf('a'), 'mkdCode'
 347   AssertEqual SyntaxOf('b'), 'mkdCode'
 348
 349 Given markdown;
 350 ```c++
 351 #include <iostream>
 352 code
 353 ```
 354
 355 ```ruby
 356 def a
 357 end
 358 ```
 359
 360 Execute (fenced code block syntax with a language specifier):
 361   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
 362   call b:func(0)
 363   AssertEqual SyntaxOf('include'), 'cInclude'
 364   AssertEqual SyntaxOf('code'), 'mkdSnippetCPP'
 365   AssertEqual SyntaxOf('def'), 'rubyDefine'
 366
 367 Given markdown;
 368 ```a+b-
 369 code
 370 ```
 371
 372 Execute (fenced code block syntax with an unknown language specifier):
 373   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
 374   call b:func(0)
 375   AssertEqual SyntaxOf('code'), 'mkdSnippetA_B_'
 376
 377
 378 Given markdown;
 379 ```
 380 =
 381 a
 382 -
 383 ```
 384
 385 Execute (first = or - in fenced code block is not setex headers):
 386   AssertEqual SyntaxOf('='), 'mkdCode'
 387   AssertEqual SyntaxOf('-'), 'mkdCode'
 388
 389 # Math
 390
 391 Given markdown;
 392 a $x$ b
 393 c $$y$$ d
 394 \$e\$
 395 \$\$f\$\$
 396
 397 Execute (math):
 398   AssertNotEqual SyntaxOf('x'), 'mkdMath'
 399   AssertNotEqual SyntaxOf('y'), 'mkdMath'
 400   let g:vim_markdown_math=1
 401   syn off | syn on
 402   AssertNotEqual SyntaxOf('a'), 'mkdMath'
 403   AssertNotEqual SyntaxOf('b'), 'mkdMath'
 404   AssertNotEqual SyntaxOf('c'), 'mkdMath'
 405   AssertNotEqual SyntaxOf('d'), 'mkdMath'
 406   AssertNotEqual SyntaxOf('e'), 'mkdMath'
 407   AssertNotEqual SyntaxOf('f'), 'mkdMath'
 408   AssertEqual SyntaxOf('x'), 'mkdMath'
 409   AssertEqual SyntaxOf('y'), 'mkdMath'
 410   let g:vim_markdown_math=0
 411   syn off | syn on
 412   AssertNotEqual SyntaxOf('x'), 'mkdMath'
 413   AssertNotEqual SyntaxOf('y'), 'mkdMath'
 414
 415 Given markdown;
 416 a
 417
 418 $
 419 b
 420 $
 421
 422 c
 423
 424 Execute (multiline math):
 425   let g:vim_markdown_math=1
 426   syn off | syn on
 427   AssertNotEqual SyntaxOf('a'), 'mkdMath'
 428   AssertEqual SyntaxOf('b'), 'mkdMath'
 429   AssertNotEqual SyntaxOf('c'), 'mkdMath'
 430
 431 Given markdown;
 432 $ \sqrt{a}{b} $
 433 $$ \frac{a}{b} $$
 434
 435 Execute (math tex highlighting):
 436   let g:vim_markdown_math=0
 437   syn off | syn on
 438   AssertNotEqual SyntaxOf('sqrt'), 'texStatement'
 439   AssertNotEqual SyntaxOf('frac'), 'texStatement'
 440   let g:vim_markdown_math=1
 441   syn off | syn on
 442   AssertEqual SyntaxOf('sqrt'), 'texStatement'
 443   AssertEqual SyntaxOf('frac'), 'texStatement'
 444
 445 # YAML frontmatter
 446
 447 Given markdown;
 448 ---
 449 a: b
 450 ---
 451
 452 Execute (YAML frontmatter is controlled by the option):
 453   AssertNotEqual SyntaxOf('a'), 'yamlBlockMappingKey'
 454   let g:vim_markdown_frontmatter=1
 455   syn off | syn on
 456   AssertEqual SyntaxOf('a'), 'yamlBlockMappingKey'
 457   let g:vim_markdown_frontmatter=0
 458   syn off | syn on
 459   AssertNotEqual SyntaxOf('a'), 'yamlBlockMappingKey'
 460
 461 Given markdown;
 462
 463 ---
 464 a: b
 465 ---
 466
 467 Execute (YAML frontmatter only works if it's the first thing in the file):
 468   let g:vim_markdown_frontmatter=1
 469   syn off | syn on
 470   AssertNotEqual SyntaxOf('a'), 'yamlBlockMappingKey'
 471
 472 Given markdown;
 473 ---
 474 a: b
 475 ---
 476
 477 ---
 478
 479 Execute (rules are not mistaken by YAML frontmatter delimiters):
 480   let g:vim_markdown_frontmatter=1
 481   syn off | syn on
 482   AssertEqual SyntaxAt(5, 1), 'mkdRule'
 483
 484 # Header
 485
 486 Given markdown;
 487 # #a
 488 ccc
 489
 490 ## #b
 491 ddd
 492
 493 Execute (header title starts with #):
 494   AssertEqual SyntaxOf('a'), 'htmlH1'
 495   AssertEqual SyntaxOf('b'), 'htmlH2'
 496
 497 Given markdown;
 498 # h1 space
 499
 500 #h1 nospace
 501
 502 #  h1 2 spaces
 503
 504 # h1 trailing hash #
 505
 506 ## h2 space
 507
 508 ##h2 nospace
 509
 510 ## h2 trailing hash ##
 511
 512 ### h3 space
 513
 514 ###h3 nospace
 515
 516 ### h3 trailing hash ###
 517
 518 #### h4
 519
 520 ##### h5
 521
 522 ###### h6
 523
 524 Execute (atx headers):
 525   AssertEqual SyntaxOf('# h1 space'), 'htmlH1'
 526   AssertEqual SyntaxOf('#h1 nospace'), 'htmlH1'
 527   AssertEqual SyntaxOf('#  h1 2 spaces'), 'htmlH1'
 528   AssertEqual SyntaxOf('# h1 trailing hash #'), 'htmlH1'
 529   AssertEqual SyntaxOf('## h2 space'), 'htmlH2'
 530   AssertEqual SyntaxOf('##h2 nospace'), 'htmlH2'
 531   AssertEqual SyntaxOf('## h2 trailing hash ##'), 'htmlH2'
 532   AssertEqual SyntaxOf('### h3 space'), 'htmlH3'
 533   AssertEqual SyntaxOf('###h3 nospace'), 'htmlH3'
 534   AssertEqual SyntaxOf('### h3 trailing hash ###'), 'htmlH3'
 535   AssertEqual SyntaxOf('#### h4'), 'htmlH4'
 536   AssertEqual SyntaxOf('##### h5'), 'htmlH5'
 537   AssertEqual SyntaxOf('###### h6'), 'htmlH6'
 538
 539 Given markdown;
 540 # h1 before h2
 541
 542 ## h2 between h1s
 543
 544 # h1 after h2
 545
 546 Execute (atx headers relative positions):
 547   AssertEqual SyntaxOf('# h1 before h2'), 'htmlH1'
 548   AssertEqual SyntaxOf('## h2 between h1s'), 'htmlH2'
 549   AssertEqual SyntaxOf('# h1 after h2'), 'htmlH1'
 550
 551 Given markdown;
 552 setex h1
 553 ========
 554
 555 setex h2
 556 --------
 557
 558 setex h1 single punctuation
 559 =
 560
 561 setex h1 punctuation longer than header
 562 ================================
 563
 564 Execute (setex headers):
 565   AssertEqual SyntaxOf('setex h1'), 'htmlH1'
 566   AssertEqual SyntaxOf('^========$'), 'htmlH1'
 567   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
 568   AssertEqual SyntaxOf('--------'), 'htmlH2'
 569   AssertEqual SyntaxOf('setex h1 single punctuation'), 'htmlH1'
 570   AssertEqual SyntaxOf('^=$'), 'htmlH1'
 571   AssertEqual SyntaxOf('setex h1 punctuation longer than header'), 'htmlH1'
 572   AssertEqual SyntaxOf('^================================$'), 'htmlH1'
 573
 574 Given markdown;
 575 - not Setex
 576 - because list
 577
 578 Execute (prevent list vs Setex confusion):
 579   AssertNotEqual SyntaxOf('- not Setex'), 'htmlH2'
 580   AssertNotEqual SyntaxOf('- becuase list'), 'htmlH2'
 581
 582 Given markdown;
 583 setex h1 before atx
 584 ===================
 585
 586 ## atx h2
 587
 588 ### atx h3
 589
 590 # atx h1
 591
 592 setex h2
 593 ------------------
 594
 595 ### atx h3 2
 596
 597 Execute (mixed atx and setex headers):
 598   AssertEqual SyntaxOf('setex h1 before atx'), 'htmlH1'
 599   AssertEqual SyntaxOf('==================='), 'htmlH1'
 600   AssertEqual SyntaxOf('## atx h2'), 'htmlH2'
 601   AssertEqual SyntaxOf('### atx h3'), 'htmlH3'
 602   AssertEqual SyntaxOf('# atx h1'), 'htmlH1'
 603   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
 604   AssertEqual SyntaxOf('------------------'), 'htmlH2'
 605
 606 # List
 607
 608 Given markdown;
 609 - a & b
 610 1. c > d
 611
 612 Execute (& and > are not marked as htmlError in lists):
 613   AssertEqual SyntaxOf('-'), 'mkdListItem'
 614   AssertEqual SyntaxOf('1.'), 'mkdListItem'
 615   AssertNotEqual SyntaxOf('&'), 'htmlError'
 616   AssertNotEqual SyntaxOf('>'), 'htmlError'
 617
 618 # HTML
 619
 620 Given markdown;
 621 a
 622
 623 <p>b</p>
 624
 625 - <span>c</span>
 626
 627 Execute (HTML tag in text):
 628   AssertEqual SyntaxOf('p'), 'htmlTagName'
 629   AssertEqual SyntaxOf('<p>'), 'htmlTag'
 630   AssertEqual SyntaxOf('</p>'), 'htmlEndTag'
 631   AssertEqual SyntaxOf('span'), 'htmlTagName'
 632   AssertEqual SyntaxOf('<span>'), 'htmlTag'
 633   AssertEqual SyntaxOf('</span>'), 'htmlEndTag'