]> 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:

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