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