]> git.madduck.net Git - etc/vim.git/blob - test/syntax.vader

madduck's git repository

Every one of the projects in this repository is available at the canonical URL git://git.madduck.net/madduck/pub/<projectpath> — see each project's metadata for the exact URL.

All patches and comments are welcome. Please squash your changes to logical commits before using git-format-patch and git-send-email to patches@git.madduck.net. If you'd read over the Git project's submission guidelines and adhered to them, I'd be especially grateful.

SSH access, as well as push access can be individually arranged.

If you use my repositories frequently, consider adding the following snippet to ~/.gitconfig and using the third clone URL listed for each project:

[url "git://git.madduck.net/madduck/"]
  insteadOf = madduck:

894ed0ed060b4df2202d4b5b1a0b65b3cc23d130
[etc/vim.git] / 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'