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

b5d1937fd655d431ceee4454a68d7f757467fb66
[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 (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     a
268     b
269
270 Execute (indent code block at beginning of file):
271   AssertEqual SyntaxOf('a'), 'mkdCode'
272   AssertEqual SyntaxOf('b'), 'mkdCode'
273
274 Given markdown;
275 ```c++
276 #include <iostream>
277 code
278 ```
279
280 ```ruby
281 def a
282 end
283 ```
284
285 Execute (fenced code block syntax with a language specifier):
286   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
287   call b:func(0)
288   AssertEqual SyntaxOf('include'), 'cInclude'
289   AssertEqual SyntaxOf('code'), 'mkdSnippetCPP'
290   AssertEqual SyntaxOf('def'), 'rubyDefine'
291
292 Given markdown;
293 ```a+b-
294 code
295 ```
296
297 Execute (fenced code block syntax with an unknown language specifier):
298   let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
299   call b:func(0)
300   AssertEqual SyntaxOf('code'), 'mkdSnippetA_B_'
301
302
303 Given markdown;
304 ```
305 =
306 a
307 -
308 ```
309
310 Execute (first = or - in fenced code block is not setex headers):
311   AssertEqual SyntaxOf('='), 'mkdCode'
312   AssertEqual SyntaxOf('-'), 'mkdCode'
313
314 # Math
315
316 Given markdown;
317 a $x$ b
318 c $$y$$ d
319 \$e\$
320 \$\$f\$\$
321
322 Execute (math):
323   AssertNotEqual SyntaxOf('x'), 'mkdMath'
324   AssertNotEqual SyntaxOf('y'), 'mkdMath'
325   let g:vim_markdown_math=1
326   syn off | syn on
327   AssertNotEqual SyntaxOf('a'), 'mkdMath'
328   AssertNotEqual SyntaxOf('b'), 'mkdMath'
329   AssertNotEqual SyntaxOf('c'), 'mkdMath'
330   AssertNotEqual SyntaxOf('d'), 'mkdMath'
331   AssertNotEqual SyntaxOf('e'), 'mkdMath'
332   AssertNotEqual SyntaxOf('f'), 'mkdMath'
333   AssertEqual SyntaxOf('x'), 'mkdMath'
334   AssertEqual SyntaxOf('y'), 'mkdMath'
335   let g:vim_markdown_math=0
336   syn off | syn on
337   AssertNotEqual SyntaxOf('x'), 'mkdMath'
338   AssertNotEqual SyntaxOf('y'), 'mkdMath'
339
340 Given markdown;
341 a
342
343 $
344 b
345 $
346
347 c
348
349 Execute (multiline math):
350   let g:vim_markdown_math=1
351   syn off | syn on
352   AssertNotEqual SyntaxOf('a'), 'mkdMath'
353   AssertEqual SyntaxOf('b'), 'mkdMath'
354   AssertNotEqual SyntaxOf('c'), 'mkdMath'
355
356 Given markdown;
357 $ \sqrt{a}{b} $
358 $$ \frac{a}{b} $$
359
360 Execute (math tex highlighting):
361   let g:vim_markdown_math=0
362   syn off | syn on
363   AssertNotEqual SyntaxOf('sqrt'), 'texStatement'
364   AssertNotEqual SyntaxOf('frac'), 'texStatement'
365   let g:vim_markdown_math=1
366   syn off | syn on
367   AssertEqual SyntaxOf('sqrt'), 'texStatement'
368   AssertEqual SyntaxOf('frac'), 'texStatement'
369
370 # YAML frontmatter
371
372 Given markdown;
373 ---
374 a: b
375 ---
376
377 Execute (YAML frontmatter is controlled by the option):
378   AssertNotEqual SyntaxOf('a'), 'yamlBlockMappingKey'
379   let g:vim_markdown_frontmatter=1
380   syn off | syn on
381   AssertEqual SyntaxOf('a'), 'yamlBlockMappingKey'
382   let g:vim_markdown_frontmatter=0
383   syn off | syn on
384   AssertNotEqual SyntaxOf('a'), 'yamlBlockMappingKey'
385
386 Given markdown;
387
388 ---
389 a: b
390 ---
391
392 Execute (YAML frontmatter only works if it's the first thing in the file):
393   let g:vim_markdown_frontmatter=1
394   syn off | syn on
395   AssertNotEqual SyntaxOf('a'), 'yamlBlockMappingKey'
396
397 Given markdown;
398 ---
399 a: b
400 ---
401
402 ---
403
404 Execute (rules are not mistaken by YAML frontmatter delimiters):
405   let g:vim_markdown_frontmatter=1
406   syn off | syn on
407   AssertEqual SyntaxAt(5, 1), 'mkdRule'
408
409 # Header
410
411 Given markdown;
412 # #a
413 ccc
414
415 ## #b
416 ddd
417
418 Execute (header title starts with #):
419   AssertEqual SyntaxOf('a'), 'htmlH1'
420   AssertEqual SyntaxOf('b'), 'htmlH2'
421
422 Given markdown;
423 # h1 space
424
425 #h1 nospace
426
427 #  h1 2 spaces
428
429 # h1 trailing hash #
430
431 ## h2 space
432
433 ##h2 nospace
434
435 ## h2 trailing hash ##
436
437 ### h3 space
438
439 ###h3 nospace
440
441 ### h3 trailing hash ###
442
443 #### h4
444
445 ##### h5
446
447 ###### h6
448
449 Execute (atx headers):
450   AssertEqual SyntaxOf('# h1 space'), 'htmlH1'
451   AssertEqual SyntaxOf('#h1 nospace'), 'htmlH1'
452   AssertEqual SyntaxOf('#  h1 2 spaces'), 'htmlH1'
453   AssertEqual SyntaxOf('# h1 trailing hash #'), 'htmlH1'
454   AssertEqual SyntaxOf('## h2 space'), 'htmlH2'
455   AssertEqual SyntaxOf('##h2 nospace'), 'htmlH2'
456   AssertEqual SyntaxOf('## h2 trailing hash ##'), 'htmlH2'
457   AssertEqual SyntaxOf('### h3 space'), 'htmlH3'
458   AssertEqual SyntaxOf('###h3 nospace'), 'htmlH3'
459   AssertEqual SyntaxOf('### h3 trailing hash ###'), 'htmlH3'
460   AssertEqual SyntaxOf('#### h4'), 'htmlH4'
461   AssertEqual SyntaxOf('##### h5'), 'htmlH5'
462   AssertEqual SyntaxOf('###### h6'), 'htmlH6'
463
464 Given markdown;
465 # h1 before h2
466
467 ## h2 between h1s
468
469 # h1 after h2
470
471 Execute (atx headers relative positions):
472   AssertEqual SyntaxOf('# h1 before h2'), 'htmlH1'
473   AssertEqual SyntaxOf('## h2 between h1s'), 'htmlH2'
474   AssertEqual SyntaxOf('# h1 after h2'), 'htmlH1'
475
476 Given markdown;
477 setex h1
478 ========
479
480 setex h2
481 --------
482
483 setex h1 single punctuation
484 =
485
486 setex h1 punctuation longer than header
487 ================================
488
489 Execute (setex headers):
490   AssertEqual SyntaxOf('setex h1'), 'htmlH1'
491   AssertEqual SyntaxOf('^========$'), 'htmlH1'
492   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
493   AssertEqual SyntaxOf('--------'), 'htmlH2'
494   AssertEqual SyntaxOf('setex h1 single punctuation'), 'htmlH1'
495   AssertEqual SyntaxOf('^=$'), 'htmlH1'
496   AssertEqual SyntaxOf('setex h1 punctuation longer than header'), 'htmlH1'
497   AssertEqual SyntaxOf('^================================$'), 'htmlH1'
498
499 Given markdown;
500 - not Setex
501 - because list
502
503 Execute (prevent list vs Setex confusion):
504   AssertNotEqual SyntaxOf('- not Setex'), 'htmlH2'
505   AssertNotEqual SyntaxOf('- becuase list'), 'htmlH2'
506
507 Given markdown;
508 setex h1 before atx
509 ===================
510
511 ## atx h2
512
513 ### atx h3
514
515 # atx h1
516
517 setex h2
518 ------------------
519
520 ### atx h3 2
521
522 Execute (mixed atx and setex headers):
523   AssertEqual SyntaxOf('setex h1 before atx'), 'htmlH1'
524   AssertEqual SyntaxOf('==================='), 'htmlH1'
525   AssertEqual SyntaxOf('## atx h2'), 'htmlH2'
526   AssertEqual SyntaxOf('### atx h3'), 'htmlH3'
527   AssertEqual SyntaxOf('# atx h1'), 'htmlH1'
528   AssertEqual SyntaxOf('setex h2'), 'htmlH2'
529   AssertEqual SyntaxOf('------------------'), 'htmlH2'
530
531 # List
532
533 Given markdown;
534 - a & b
535 1. c > d
536
537 Execute (& and > are not marked as htmlError in lists):
538   AssertEqual SyntaxOf('-'), 'mkdListItem'
539   AssertEqual SyntaxOf('1.'), 'mkdListItem'
540   AssertNotEqual SyntaxOf('&'), 'htmlError'
541   AssertNotEqual SyntaxOf('>'), 'htmlError'
542
543 # HTML
544
545 Given markdown;
546 a
547
548 <p>b</p>
549
550 - <span>c</span>
551
552 Execute (HTML tag in text):
553   AssertEqual SyntaxOf('p'), 'htmlTagName'
554   AssertEqual SyntaxOf('<p>'), 'htmlTag'
555   AssertEqual SyntaxOf('</p>'), 'htmlEndTag'
556   AssertEqual SyntaxOf('span'), 'htmlTagName'
557   AssertEqual SyntaxOf('<span>'), 'htmlTag'
558   AssertEqual SyntaxOf('</span>'), 'htmlEndTag'