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

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