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 b](c)
 163
 164 Execute (link text with newline):
 165   AssertEqual SyntaxOf('a'), 'mkdLink'
 166   AssertEqual SyntaxOf('b'), 'mkdLink'
 167   AssertEqual SyntaxOf('c'), 'mkdURL'
 168
 169 Given markdown;
 170 (a)
 171
 172 (b)
 173
 174 Execute (parenthesis not in link):
 175   AssertNotEqual SyntaxOf('a'), 'mkdURL'
 176   AssertNotEqual SyntaxOf('b'), 'mkdURL'
 177
 178 Given markdown;
 179 [a](b) c [d](e)
 180
 181 Execute (multiple links on a line):
 182   AssertNotEqual SyntaxOf('c'), 'mkdLink'
 183   AssertNotEqual SyntaxOf('c'), 'mkdURL'
 184
 185 Given markdown;
 186 [a] (b)
 187
 188 Execute (space is not allowed between link text and parenthesis):
 189   AssertNotEqual SyntaxOf('a'), 'mkdLink'
 190   AssertNotEqual SyntaxOf('b'), 'mkdURL'
 191
 192 Given markdown;
 193 [a](b)
 194
 195 Execute (conceal link):
 196   if has('conceal')
 197     setlocal conceallevel=2
 198     AssertEqual synconcealed(1, 1)[0], 1
 199     AssertEqual synconcealed(1, 2)[0], 0
 200     AssertEqual synconcealed(1, 3)[0], 1
 201     AssertEqual synconcealed(1, 4)[0], 1
 202     AssertEqual synconcealed(1, 4)[0], 1
 203     AssertEqual synconcealed(1, 5)[0], 1
 204     AssertEqual synconcealed(1, 6)[0], 1
 205     setlocal conceallevel=0
 206   endif
 207
 208 # Autolinks
 209
 210 Given markdown;
 211 a <http://b> c
 212
 213 Execute (autolink):
 214   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
 215   AssertEqual SyntaxOf('<'), 'mkdDelimiter'
 216   AssertEqual SyntaxOf('b'), 'mkdInlineURL'
 217   AssertEqual SyntaxOf('>'), 'mkdDelimiter'
 218   AssertNotEqual SyntaxOf('c'), 'mkdInlineURL'
 219
 220 Given markdown;
 221 http://12monkeys.foo
 222
 223 Execute (autolink with domain starting with a number):
 224   AssertEqual SyntaxOf('12monkeys'), 'mkdInlineURL'
 225
 226 Given markdown;
 227 <HtTp://a>
 228
 229 Execute (autolink with scheme case is insensitive):
 230   AssertEqual SyntaxOf('a'), 'mkdInlineURL'
 231
 232 Given markdown;
 233 <a>
 234
 235 Execute (autolink without scheme is not a link):
 236   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
 237
 238 Given markdown;
 239 < http://a >
 240 <http://b c>
 241 <http://d
 242 e>
 243
 244 Execute (autolink with space is not a link):
 245   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
 246   AssertNotEqual SyntaxOf('b'), 'mkdInlineURL'
 247   AssertNotEqual SyntaxOf('c'), 'mkdInlineURL'
 248   AssertNotEqual SyntaxOf('d'), 'mkdInlineURL'
 249   AssertNotEqual SyntaxOf('e'), 'mkdInlineURL'
 250
 251 Given markdown;
 252 \<http://a>
 253
 254 Execute (autolinks can be backslash escaped):
 255   AssertNotEqual SyntaxOf('<'), 'mkdDelimiter'
 256
 257 Given markdown;
 258 a (http://b.bb) c
 259
 260 Execute (autolink in parenthesis):
 261   AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
 262   AssertEqual SyntaxOf('('), 'mkdDelimiter'
 263   AssertEqual SyntaxOf('b'), 'mkdInlineURL'
 264   AssertEqual SyntaxOf(')'), 'mkdDelimiter'
 265   AssertNotEqual SyntaxOf('c'), 'mkdInlineURL'
 266
 267 Given markdown;
 268 [![a](http://b)](http://c)
 269
 270 Execute (autolink in link text):
 271   AssertEqual SyntaxOf('!'), 'mkdDelimiter'
 272   AssertEqual SyntaxOf('a'), 'mkdLink'
 273   AssertEqual SyntaxOf('b'), 'mkdURL'
 274   AssertEqual SyntaxOf('c'), 'mkdURL'
 275
 276 # Code Blocks
 277
 278 Given markdown;
 279 ~~~
 280 code
 281 ~~~
 282
 283 Execute (code blocks can be fenced with tildes):
 284   AssertEqual SyntaxOf('c'), 'mkdCode'
 285
 286 Given markdown;
 287 ~~~~
 288 code
 289 ~~~~~
 290
 291 Execute (code blocks can be fenced with tildes longer than 3):
 292   AssertEqual SyntaxOf('c'), 'mkdCode'
 293
 294 Given markdown;
 295 ````
 296 code
 297 `````
 298
 299 Execute (code blocks can be fenced with backticks longer than 3):
 300   AssertEqual SyntaxOf('c'), 'mkdCode'
 301
 302 Given markdown;
 303 ~~~ruby
 304 code
 305 ~~~
 306
 307 Execute (code blocks can have a language specifier):
 308   AssertEqual SyntaxOf('c'), 'mkdCode'
 309
 310 Given markdown;
 311 ```c++
 312 code
 313 ```
 314
 315 text
 316
 317 Execute (code blocks can be fenced with backticks and a language specifier):
 318   AssertEqual SyntaxOf('code'), 'mkdCode'
 319   AssertNotEqual SyntaxOf('text'), 'mkdCode'
 320
 321 # Indent Code Blocks
 322
 323 Given markdown;
 324 a
 325
 326     b
 327     c
 328
 329 Execute (indent code blocks):
 330   AssertNotEqual SyntaxOf('a'), 'mkdCode'
 331   AssertEqual SyntaxOf('b'), 'mkdCode'
 332   AssertEqual SyntaxOf('c'), 'mkdCode'
 333
 334 Given markdown;
 335 # a
 336
 337 b
 338
 339     c
 340
 341 Execute (indent code blocks after header):
 342   AssertNotEqual SyntaxOf('a'), 'mkdCode'
 343   AssertNotEqual SyntaxOf('b'), 'mkdCode'
 344   AssertEqual SyntaxOf('c'), 'mkdCode'
 345
 346 Given markdown;
 347 -   a
 348
 349     b
 350
 351         c
 352
 353 Execute (indent code blocks after list):
 354   AssertNotEqual SyntaxOf('a'), 'mkdCode'
 355   AssertNotEqual SyntaxOf('b'), 'mkdCode'
 356   AssertEqual SyntaxOf('c'), 'mkdCode'
 357
 358 Given markdown;
 359     a
 360     b
 361
 362 Execute (indent code block at beginning of file):
 363   AssertEqual SyntaxOf('a'), 'mkdCode'
 364   AssertEqual SyntaxOf('b'), 'mkdCode'
 365
 366 Given markdown;
 367 ```c++
 368 #include <iostream>
 369 code
 370 ```
 371
 372 ```ruby
 373 def a
 374 end
 375 ```
 376
 377 Execute (fenced code block syntax with a language specifier):
 378   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
 379   call b:func(0)
 380   AssertEqual SyntaxOf('include'), 'cInclude'
 381   AssertEqual SyntaxOf('code'), 'mkdSnippetCPP'
 382   AssertEqual SyntaxOf('def'), 'rubyDefine'
 383
 384 Given markdown;
 385 ```vim
 386 let g:a = 1
 387 ```
 388
 389 ```viml
 390 let g:b = 1
 391 ```
 392
 393 Execute (fenced code block syntax with alias language specifier):
 394   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
 395   call b:func(0)
 396   AssertEqual SyntaxOf('g:a'), 'vimVar'
 397   AssertEqual SyntaxOf('g:b'), 'vimVar'
 398
 399 Given markdown;
 400 ```a+b-
 401 code
 402 ```
 403
 404 Execute (fenced code block syntax with an unknown language specifier):
 405   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
 406   call b:func(0)
 407   AssertEqual SyntaxOf('code'), 'mkdSnippetA_B_'
 408
 409 Given markdown;
 410 ```
 411 =
 412 a
 413 -
 414 ```
 415
 416 Execute (first = or - in fenced code block is not setex headers):
 417   AssertEqual SyntaxOf('='), 'mkdCode'
 418   AssertEqual SyntaxOf('-'), 'mkdCode'
 419
 420 Given markdown;
 421 ``` {style=""}
 422 a
 423 ```
 424
 425 Execute (fenced code block with extended info strings):
 426   AssertEqual SyntaxOf('a'), 'mkdCode'
 427
 428 # Code Blocks in pre and code tag
 429
 430 Given markdown;
 431 <pre>
 432 a
 433 </pre>
 434
 435 Execute (code block in pre tag):
 436   AssertEqual SyntaxOf('a'), 'mkdCode'
 437
 438 Given markdown;
 439 <code>
 440 a
 441 </code>
 442
 443 Execute (code block in code tag):
 444   AssertEqual SyntaxOf('a'), 'mkdCode'
 445
 446 Given markdown;
 447 \<pre\>
 448 a
 449 \</pre\>
 450
 451 Execute (not code block in escaped pre tag):
 452   AssertNotEqual SyntaxOf('a'), 'mkdCode'
 453
 454 Given markdown;
 455 \<code\>
 456 a
 457 \</code\>
 458
 459 Execute (not code block in escaped code tag):
 460   AssertNotEqual SyntaxOf('a'), 'mkdCode'
 461
 462 # Math
 463
 464 Given markdown;
 465 a $x$ b
 466 c $$y$$ d
 467 \$e\$
 468 \$\$f\$\$
 469
 470 Execute (math):
 471   AssertNotEqual SyntaxOf('x'), 'mkdMath'
 472   AssertNotEqual SyntaxOf('y'), 'mkdMath'
 473   let g:vim_markdown_math=1
 474   syn off | syn on
 475   AssertNotEqual SyntaxOf('a'), 'mkdMath'
 476   AssertNotEqual SyntaxOf('b'), 'mkdMath'
 477   AssertNotEqual SyntaxOf('c'), 'mkdMath'
 478   AssertNotEqual SyntaxOf('d'), 'mkdMath'
 479   AssertNotEqual SyntaxOf('e'), 'mkdMath'
 480   AssertNotEqual SyntaxOf('f'), 'mkdMath'
 481   AssertEqual SyntaxOf('x'), 'mkdMath'
 482   AssertEqual SyntaxOf('y'), 'mkdMath'
 483   let g:vim_markdown_math=0
 484   syn off | syn on
 485   AssertNotEqual SyntaxOf('x'), 'mkdMath'
 486   AssertNotEqual SyntaxOf('y'), 'mkdMath'
 487
 488 Given markdown;
 489 a
 490
 491 $
 492 b
 493 $
 494
 495 c
 496
 497 Execute (multiline math):
 498   let g:vim_markdown_math=1
 499   syn off | syn on
 500   AssertNotEqual SyntaxOf('a'), 'mkdMath'
 501   AssertEqual SyntaxOf('b'), 'mkdMath'
 502   AssertNotEqual SyntaxOf('c'), 'mkdMath'
 503
 504 Given markdown;
 505 $ \sqrt{a}{b} $
 506 $$ \frac{a}{b} $$
 507
 508 Execute (math tex highlighting):
 509   let g:vim_markdown_math=0
 510   syn off | syn on
 511   AssertNotEqual SyntaxOf('sqrt'), 'texStatement'
 512   AssertNotEqual SyntaxOf('frac'), 'texStatement'
 513   let g:vim_markdown_math=1
 514   syn off | syn on
 515   AssertEqual SyntaxOf('sqrt'), 'texStatement'
 516   AssertEqual SyntaxOf('frac'), 'texStatement'
 517
 518 # YAML frontmatter
 519
 520 Given markdown;
 521 ---
 522 a: b
 523 ---
 524
 525 Execute (YAML frontmatter is controlled by the option):
 526   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
 527   let g:vim_markdown_frontmatter=1
 528   syn off | syn on
 529   AssertEqual SyntaxOf('a')[0:3], 'yaml'
 530   let g:vim_markdown_frontmatter=0
 531   syn off | syn on
 532   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
 533
 534 Given markdown;
 535
 536 ---
 537 a: b
 538 ---
 539
 540 Execute (YAML frontmatter only works if it's the first thing in the file):
 541   let g:vim_markdown_frontmatter=1
 542   syn off | syn on
 543   AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
 544
 545 Given markdown;
 546 ---
 547 a: b
 548 ---
 549
 550 ---
 551
 552 Execute (rules are not mistaken by YAML frontmatter delimiters):
 553   let g:vim_markdown_frontmatter=1
 554   syn off | syn on
 555   AssertEqual SyntaxAt(5, 1), 'mkdRule'
 556   unlet g:vim_markdown_frontmatter
 557
 558 # TOML frontmatter
 559
 560 Given markdown;
 561 +++
 562 a = "b"
 563 +++
 564
 565 Execute (TOML frontmatter is controlled by the option):
 566   syn off | syn on
 567   AssertNotEqual SyntaxOf('b'), 'tomlString'
 568   let g:vim_markdown_toml_frontmatter=1
 569   syn off | syn on
 570   AssertEqual SyntaxOf('b'), 'tomlString'
 571   let g:vim_markdown_toml_frontmatter=0
 572   syn off | syn on
 573   AssertNotEqual SyntaxOf('b'), 'tomlString'
 574
 575 Given markdown;
 576
 577 +++
 578 a = "b"
 579 +++
 580
 581 Execute (TOML frontmatter only works if it's the first thing in the file):
 582   let g:vim_markdown_toml_frontmatter=1
 583   syn off | syn on
 584   AssertNotEqual SyntaxOf('b'), 'tomlString'
 585   unlet g:vim_markdown_toml_frontmatter
 586
 587 # JSON frontmatter
 588
 589 Given markdown;
 590 {
 591   "a": "b"
 592 }
 593
 594 Execute (JSON frontmatter is controlled by the option):
 595   syn off | syn on
 596   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
 597   let g:vim_markdown_json_frontmatter=1
 598   syn off | syn on
 599   AssertEqual SyntaxOf('a'), 'jsonKeyword'
 600   let g:vim_markdown_json_frontmatter=0
 601   syn off | syn on
 602   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
 603
 604 Given markdown;
 605
 606 {
 607   "a": "b"
 608 }
 609
 610 Execute (JSON frontmatter only works if it's the first thing in the file):
 611   let g:vim_markdown_json_frontmatter=1
 612   syn off | syn on
 613   AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
 614   unlet g:vim_markdown_json_frontmatter
 615
 616 # Header
 617
 618 Given markdown;
 619 # #a
 620 ccc
 621
 622 ## #b
 623 ddd
 624
 625 Execute (header title starts with #):
 626   AssertEqual SyntaxOf('a'), 'htmlH1'
 627   AssertEqual SyntaxOf('b'), 'htmlH2'
 628
 629 Given markdown;
 630 # h1 space
 631
 632 #h1 nospace
 633
 634 #  h1 2 spaces
 635
 636 # h1 trailing hash #
 637
 638 ## h2 space
 639
 640 ##h2 nospace
 641
 642 ## h2 trailing hash ##
 643
 644 ### h3 space
 645
 646 ###h3 nospace
 647
 648 ### h3 trailing hash ###
 649
 650 #### h4
 651
 652 ##### h5
 653
 654 ###### h6
 655
 656 Execute (atx headers):
 657   AssertEqual SyntaxOf('# h1 space'), 'htmlH1'
 658   AssertEqual SyntaxOf('#h1 nospace'), 'htmlH1'
 659   AssertEqual SyntaxOf('#  h1 2 spaces'), 'htmlH1'
 660   AssertEqual SyntaxOf('# h1 trailing hash #'), 'htmlH1'
 661   AssertEqual SyntaxOf('## h2 space'), 'htmlH2'
 662   AssertEqual SyntaxOf('##h2 nospace'), 'htmlH2'
 663   AssertEqual SyntaxOf('## h2 trailing hash ##'), 'htmlH2'
 664   AssertEqual SyntaxOf('### h3 space'), 'htmlH3'
 665   AssertEqual SyntaxOf('###h3 nospace'), 'htmlH3'
 666   AssertEqual SyntaxOf('### h3 trailing hash ###'), 'htmlH3'
 667   AssertEqual SyntaxOf('#### h4'), 'htmlH4'
 668   AssertEqual SyntaxOf('##### h5'), 'htmlH5'
 669   AssertEqual SyntaxOf('###### h6'), 'htmlH6'
 670
 671 Given markdown;
 672 # h1 before h2
 673
 674 ## h2 between h1s
 675
 676 # h1 after h2
 677
 678 Execute (atx headers relative positions):
 679   AssertEqual SyntaxOf('# h1 before h2'), 'htmlH1'
 680   AssertEqual SyntaxOf('## h2 between h1s'), 'htmlH2'
 681   AssertEqual SyntaxOf('# h1 after h2'), 'htmlH1'
 682
 683 Given markdown;
 684 setex h1
 685 ========
 686
 687 setex h2
 688 --------
 689
 690 setex h1 single punctuation
 691 =
 692
 693 setex h1 punctuation longer than header
 694 ================================
 695
 696 Execute (setex headers):
 697   AssertEqual SyntaxOf('setex h1'), 'htmlH1'
 698   AssertEqual SyntaxOf('^========$'), 'htmlH1'
 699   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
 700   AssertEqual SyntaxOf('--------'), 'htmlH2'
 701   AssertEqual SyntaxOf('setex h1 single punctuation'), 'htmlH1'
 702   AssertEqual SyntaxOf('^=$'), 'htmlH1'
 703   AssertEqual SyntaxOf('setex h1 punctuation longer than header'), 'htmlH1'
 704   AssertEqual SyntaxOf('^================================$'), 'htmlH1'
 705
 706 Given markdown;
 707 - not Setex
 708 - because list
 709
 710 Execute (prevent list vs Setex confusion):
 711   AssertNotEqual SyntaxOf('- not Setex'), 'htmlH2'
 712   AssertNotEqual SyntaxOf('- becuase list'), 'htmlH2'
 713
 714 Given markdown;
 715 setex h1 before atx
 716 ===================
 717
 718 ## atx h2
 719
 720 ### atx h3
 721
 722 # atx h1
 723
 724 setex h2
 725 ------------------
 726
 727 ### atx h3 2
 728
 729 Execute (mixed atx and setex headers):
 730   AssertEqual SyntaxOf('setex h1 before atx'), 'htmlH1'
 731   AssertEqual SyntaxOf('==================='), 'htmlH1'
 732   AssertEqual SyntaxOf('## atx h2'), 'htmlH2'
 733   AssertEqual SyntaxOf('### atx h3'), 'htmlH3'
 734   AssertEqual SyntaxOf('# atx h1'), 'htmlH1'
 735   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
 736   AssertEqual SyntaxOf('------------------'), 'htmlH2'
 737
 738 # List
 739
 740 Given markdown;
 741 - a & b
 742 1. c > d
 743
 744 Execute (& and > are not marked as htmlError in lists):
 745   AssertEqual SyntaxOf('-'), 'mkdListItem'
 746   AssertEqual SyntaxOf('1.'), 'mkdListItem'
 747   AssertNotEqual SyntaxOf('&'), 'htmlError'
 748   AssertNotEqual SyntaxOf('>'), 'htmlError'
 749
 750 Given markdown;
 751 1. a
 752 2. b
 753
 754 Execute (list after line break):
 755   AssertEqual SyntaxOf('1'), 'mkdListItem'
 756   AssertEqual SyntaxOf('2'), 'mkdListItem'
 757
 758 # HTML
 759
 760 Given markdown;
 761 a
 762
 763 <p>b</p>
 764
 765 - <span>c</span>
 766
 767 Execute (HTML tag in text):
 768   AssertEqual SyntaxOf('p'), 'htmlTagName'
 769   AssertEqual SyntaxOf('<p>'), 'htmlTag'
 770   AssertEqual SyntaxOf('</p>'), 'htmlEndTag'
 771   AssertEqual SyntaxOf('span'), 'htmlTagName'
 772   AssertEqual SyntaxOf('<span>'), 'htmlTag'
 773   AssertEqual SyntaxOf('</span>'), 'htmlEndTag'