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

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