psi-jack/ultimate-vim
1
0
Fork 0
mirror of synced 2024-11-13 20:58:57 -05:00
Code Issues Releases Wiki Activity
ultimate-vim/sources_non_forked/vim-markdown/test/syntax.vader

1529 lines
33 KiB
Text
Raw Normal View History

Updated plugins and added vim-markdown
2018-02-04 06:35:08 -05:00
Before:
unlet! b:mkd_known_filetypes
unlet! b:mkd_included_filetypes
unlet! g:vim_markdown_math
Updated vim plugins
2022-12-03 05:29:32 -05:00
unlet! b:liquid_subtype
Updated plugins and added vim-markdown
2018-02-04 06:35:08 -05:00
Given markdown;
a **b** c
Execute (bold):
AssertNotEqual SyntaxOf('a'), 'htmlBold'
AssertEqual SyntaxOf('b'), 'htmlBold'
AssertNotEqual SyntaxOf('c'), 'htmlBold'
Given markdown;
a __b__ c
Execute (bold):
AssertNotEqual SyntaxOf('a'), 'htmlBold'
AssertEqual SyntaxOf('b'), 'htmlBold'
AssertNotEqual SyntaxOf('c'), 'htmlBold'
Given markdown;
a *b* c
Execute (italic):
AssertNotEqual SyntaxOf('a'), 'htmlItalic'
AssertEqual SyntaxOf('b'), 'htmlItalic'
AssertNotEqual SyntaxOf('c'), 'htmlItalic'
Given markdown;
a _b_ c
Execute (italic):
AssertNotEqual SyntaxOf('a'), 'htmlItalic'
AssertEqual SyntaxOf('b'), 'htmlItalic'
AssertNotEqual SyntaxOf('c'), 'htmlItalic'
Given markdown;
_a_b_
Execute (italic text has underscores):
AssertEqual SyntaxOf('a'), 'htmlItalic'
AssertEqual SyntaxOf('b'), 'htmlItalic'
Given markdown;
a \*b\* c
Execute (not italic with escaped asterisks):
AssertNotEqual SyntaxOf('a'), 'htmlItalic'
AssertNotEqual SyntaxOf('b'), 'htmlItalic'
AssertNotEqual SyntaxOf('c'), 'htmlItalic'
Given markdown;
a \_b\_ c
Execute (not italic with escaped underscores):
AssertNotEqual SyntaxOf('a'), 'htmlItalic'
AssertNotEqual SyntaxOf('b'), 'htmlItalic'
AssertNotEqual SyntaxOf('c'), 'htmlItalic'
Given markdown;
a _b\_c_ d
Execute (italic with escaped underscores):
AssertNotEqual SyntaxOf('a'), 'htmlItalic'
AssertEqual SyntaxOf('b'), 'htmlItalic'
AssertEqual SyntaxOf('c'), 'htmlItalic'
AssertNotEqual SyntaxOf('d'), 'htmlItalic'
Given markdown;
a_b_c
Execute (not italic underscores within text):
AssertNotEqual SyntaxOf('a'), 'htmlItalic'
AssertNotEqual SyntaxOf('b'), 'htmlItalic'
AssertNotEqual SyntaxOf('c'), 'htmlItalic'
Given markdown;
a *b\*c* d
Execute (italic with escaped asterisks):
AssertNotEqual SyntaxOf('a'), 'htmlItalic'
AssertEqual SyntaxOf('b'), 'htmlItalic'
AssertEqual SyntaxOf('c'), 'htmlItalic'
AssertNotEqual SyntaxOf('d'), 'htmlItalic'
Given markdown;
a __b\_\_c__ d
Execute (bold with escaped underscores):
AssertNotEqual SyntaxOf('a'), 'htmlBold'
AssertEqual SyntaxOf('b'), 'htmlBold'
AssertEqual SyntaxOf('c'), 'htmlBold'
AssertNotEqual SyntaxOf('d'), 'htmlBold'
Given markdown;
_a b
c_ d
Execute (italic with underscores in multiple lines):
AssertEqual SyntaxOf('a'), 'htmlItalic'
AssertEqual SyntaxOf('b'), 'htmlItalic'
AssertEqual SyntaxOf('c'), 'htmlItalic'
AssertNotEqual SyntaxOf('d'), 'htmlItalic'
Given markdown;
__a b
c__ d
Execute (bold with underscores in multiple lines):
AssertEqual SyntaxOf('a'), 'htmlBold'
AssertEqual SyntaxOf('b'), 'htmlBold'
AssertEqual SyntaxOf('c'), 'htmlBold'
AssertNotEqual SyntaxOf('d'), 'htmlBold'
Given markdown;
___a b
c___ d
Execute (bold italic with underscores in multiple lines):
AssertEqual SyntaxOf('a'), 'htmlBoldItalic'
AssertEqual SyntaxOf('b'), 'htmlBoldItalic'
AssertEqual SyntaxOf('c'), 'htmlBoldItalic'
AssertNotEqual SyntaxOf('d'), 'htmlBoldItalic'
Given markdown;
*a b
c* d
Execute (italic with asterisks in multiple lines):
AssertEqual SyntaxOf('a'), 'htmlItalic'
AssertEqual SyntaxOf('b'), 'htmlItalic'
AssertEqual SyntaxOf('c'), 'htmlItalic'
AssertNotEqual SyntaxOf('d'), 'htmlItalic'
Given markdown;
**a b
c** d
Execute (bold with asterisks in multiple lines):
AssertEqual SyntaxOf('a'), 'htmlBold'
AssertEqual SyntaxOf('b'), 'htmlBold'
AssertEqual SyntaxOf('c'), 'htmlBold'
AssertNotEqual SyntaxOf('d'), 'htmlBold'
Given markdown;
***a b
c*** d
Execute (bold italic with asterisks in multiple lines):
AssertEqual SyntaxOf('a'), 'htmlBoldItalic'
AssertEqual SyntaxOf('b'), 'htmlBoldItalic'
AssertEqual SyntaxOf('c'), 'htmlBoldItalic'
AssertNotEqual SyntaxOf('d'), 'htmlBoldItalic'
Given markdown;
*a
Execute (not italic with an asterisk):
AssertNotEqual SyntaxOf('a'), 'htmlItalic'
Given markdown;
[__](a) b
Execute (not bold with double underscores):
AssertNotEqual SyntaxOf('_'), 'htmlBold'
AssertNotEqual SyntaxOf('a'), 'htmlBold'
AssertNotEqual SyntaxOf('b'), 'htmlBold'
Given markdown;
_a_
Execute (conceal italic):
if has('conceal')
setlocal conceallevel=2
AssertEqual synconcealed(1, 1)[0], 1
AssertEqual synconcealed(1, 2)[0], 0
AssertEqual synconcealed(1, 3)[0], 1
setlocal conceallevel=0
endif
Execute (disable conceal):
if has('conceal')
let g:vim_markdown_conceal=0
syn off | syn on
setlocal conceallevel=2
AssertEqual synconcealed(1, 1)[0], 0
AssertEqual synconcealed(1, 2)[0], 0
AssertEqual synconcealed(1, 3)[0], 0
let g:vim_markdown_conceal=1
syn off | syn on
AssertEqual synconcealed(1, 1)[0], 1
AssertEqual synconcealed(1, 2)[0], 0
AssertEqual synconcealed(1, 3)[0], 1
setlocal conceallevel=0
unlet g:vim_markdown_conceal
syn off | syn on
endif
Given markdown;
*a*
Execute (conceal italic):
if has('conceal')
setlocal conceallevel=2
AssertEqual synconcealed(1, 1)[0], 1
AssertEqual synconcealed(1, 2)[0], 0
AssertEqual synconcealed(1, 3)[0], 1
setlocal conceallevel=0
endif
Execute (disable conceal):
if has('conceal')
let g:vim_markdown_conceal=0
syn off | syn on
setlocal conceallevel=2
AssertEqual synconcealed(1, 1)[0], 0
AssertEqual synconcealed(1, 2)[0], 0
AssertEqual synconcealed(1, 3)[0], 0
let g:vim_markdown_conceal=1
syn off | syn on
AssertEqual synconcealed(1, 1)[0], 1
AssertEqual synconcealed(1, 2)[0], 0
AssertEqual synconcealed(1, 3)[0], 1
setlocal conceallevel=0
unlet g:vim_markdown_conceal
syn off | syn on
endif
Given markdown;
__a__
Execute (conceal bold):
if has('conceal')
setlocal conceallevel=2
AssertEqual synconcealed(1, 1)[0], 1
AssertEqual synconcealed(1, 2)[0], 1
AssertEqual synconcealed(1, 3)[0], 0
AssertEqual synconcealed(1, 4)[0], 1
AssertEqual synconcealed(1, 5)[0], 1
setlocal conceallevel=0
endif
Execute (disable conceal):
if has('conceal')
let g:vim_markdown_conceal=0
syn off | syn on
setlocal conceallevel=2
AssertEqual synconcealed(1, 1)[0], 0
AssertEqual synconcealed(1, 2)[0], 0
AssertEqual synconcealed(1, 3)[0], 0
AssertEqual synconcealed(1, 4)[0], 0
AssertEqual synconcealed(1, 5)[0], 0
let g:vim_markdown_conceal=1
syn off | syn on
AssertEqual synconcealed(1, 1)[0], 1
AssertEqual synconcealed(1, 2)[0], 1
AssertEqual synconcealed(1, 3)[0], 0
AssertEqual synconcealed(1, 4)[0], 1
AssertEqual synconcealed(1, 5)[0], 1
setlocal conceallevel=0
unlet g:vim_markdown_conceal
syn off | syn on
endif
Given markdown;
**a**
Execute (conceal bold):
if has('conceal')
setlocal conceallevel=2
AssertEqual synconcealed(1, 1)[0], 1
AssertEqual synconcealed(1, 2)[0], 1
AssertEqual synconcealed(1, 3)[0], 0
AssertEqual synconcealed(1, 4)[0], 1
AssertEqual synconcealed(1, 5)[0], 1
setlocal conceallevel=0
endif
Execute (disable conceal):
if has('conceal')
let g:vim_markdown_conceal=0
syn off | syn on
setlocal conceallevel=2
AssertEqual synconcealed(1, 1)[0], 0
AssertEqual synconcealed(1, 2)[0], 0
AssertEqual synconcealed(1, 3)[0], 0
AssertEqual synconcealed(1, 4)[0], 0
AssertEqual synconcealed(1, 5)[0], 0
let g:vim_markdown_conceal=1
syn off | syn on
AssertEqual synconcealed(1, 1)[0], 1
AssertEqual synconcealed(1, 2)[0], 1
AssertEqual synconcealed(1, 3)[0], 0
AssertEqual synconcealed(1, 4)[0], 1
AssertEqual synconcealed(1, 5)[0], 1
setlocal conceallevel=0
unlet g:vim_markdown_conceal
syn off | syn on
endif
Given markdown;
___a___
Execute (conceal italic bold):
if has('conceal')
setlocal conceallevel=2
AssertEqual synconcealed(1, 1)[0], 1
AssertEqual synconcealed(1, 2)[0], 1
AssertEqual synconcealed(1, 3)[0], 1
AssertEqual synconcealed(1, 4)[0], 0
AssertEqual synconcealed(1, 5)[0], 1
AssertEqual synconcealed(1, 6)[0], 1
AssertEqual synconcealed(1, 7)[0], 1
setlocal conceallevel=0
endif
Execute (disable conceal):
if has('conceal')
let g:vim_markdown_conceal=0
syn off | syn on
setlocal conceallevel=2
AssertEqual synconcealed(1, 1)[0], 0
AssertEqual synconcealed(1, 2)[0], 0
AssertEqual synconcealed(1, 3)[0], 0
AssertEqual synconcealed(1, 4)[0], 0
AssertEqual synconcealed(1, 5)[0], 0
AssertEqual synconcealed(1, 6)[0], 0
AssertEqual synconcealed(1, 7)[0], 0
let g:vim_markdown_conceal=1
syn off | syn on
AssertEqual synconcealed(1, 1)[0], 1
AssertEqual synconcealed(1, 2)[0], 1
AssertEqual synconcealed(1, 3)[0], 1
AssertEqual synconcealed(1, 4)[0], 0
AssertEqual synconcealed(1, 5)[0], 1
AssertEqual synconcealed(1, 6)[0], 1
AssertEqual synconcealed(1, 7)[0], 1
setlocal conceallevel=0
unlet g:vim_markdown_conceal
syn off | syn on
endif
Given markdown;
***a***
Execute (conceal italic bold):
if has('conceal')
setlocal conceallevel=2
AssertEqual synconcealed(1, 1)[0], 1
AssertEqual synconcealed(1, 2)[0], 1
AssertEqual synconcealed(1, 3)[0], 1
AssertEqual synconcealed(1, 4)[0], 0
AssertEqual synconcealed(1, 5)[0], 1
AssertEqual synconcealed(1, 6)[0], 1
AssertEqual synconcealed(1, 7)[0], 1
setlocal conceallevel=0
endif
Execute (disable conceal):
if has('conceal')
let g:vim_markdown_conceal=0
syn off | syn on
setlocal conceallevel=2
AssertEqual synconcealed(1, 1)[0], 0
AssertEqual synconcealed(1, 2)[0], 0
AssertEqual synconcealed(1, 3)[0], 0
AssertEqual synconcealed(1, 4)[0], 0
AssertEqual synconcealed(1, 5)[0], 0
AssertEqual synconcealed(1, 6)[0], 0
AssertEqual synconcealed(1, 7)[0], 0
let g:vim_markdown_conceal=1
syn off | syn on
AssertEqual synconcealed(1, 1)[0], 1
AssertEqual synconcealed(1, 2)[0], 1
AssertEqual synconcealed(1, 3)[0], 1
AssertEqual synconcealed(1, 4)[0], 0
AssertEqual synconcealed(1, 5)[0], 1
AssertEqual synconcealed(1, 6)[0], 1
AssertEqual synconcealed(1, 7)[0], 1
setlocal conceallevel=0
unlet g:vim_markdown_conceal
syn off | syn on
endif
# Links
Given markdown;
[a](b)
Execute (link with title):
AssertEqual SyntaxOf('a'), 'mkdLink'
AssertEqual SyntaxOf('b'), 'mkdURL'
Given markdown;
[a
b](c)
Execute (link text with newline):
AssertEqual SyntaxOf('a'), 'mkdLink'
AssertEqual SyntaxOf('b'), 'mkdLink'
AssertEqual SyntaxOf('c'), 'mkdURL'
Given markdown;
[a] b [c](d)
Execute (link text with bracket sections):
AssertNotEqual SyntaxOf('a'), 'mkdLink'
AssertNotEqual SyntaxOf('b'), 'mkdLink'
AssertEqual SyntaxOf('c'), 'mkdLink'
AssertEqual SyntaxOf('d'), 'mkdURL'
Given markdown;
[^a]: b
Execute (footnote is not link):
AssertNotEqual SyntaxOf('a'), 'mkdLinkDef'
Given markdown;
(a)
(b)
Execute (parenthesis not in link):
AssertNotEqual SyntaxOf('a'), 'mkdURL'
AssertNotEqual SyntaxOf('b'), 'mkdURL'
Given markdown;
[a](b) c [d](e)
Execute (multiple links on a line):
AssertNotEqual SyntaxOf('c'), 'mkdLink'
AssertNotEqual SyntaxOf('c'), 'mkdURL'
Given markdown;
[a] (b)
Execute (space is not allowed between link text and parenthesis):
AssertNotEqual SyntaxOf('a'), 'mkdLink'
AssertNotEqual SyntaxOf('b'), 'mkdURL'
Given markdown;
[a](b)
Execute (conceal link):
if has('conceal')
setlocal conceallevel=2
AssertEqual synconcealed(1, 1)[0], 1
AssertEqual synconcealed(1, 2)[0], 0
AssertEqual synconcealed(1, 3)[0], 1
AssertEqual synconcealed(1, 4)[0], 1
AssertEqual synconcealed(1, 4)[0], 1
AssertEqual synconcealed(1, 5)[0], 1
AssertEqual synconcealed(1, 6)[0], 1
setlocal conceallevel=0
endif
Execute (disable conceal):
if has('conceal')
let g:vim_markdown_conceal=0
syn off | syn on
setlocal conceallevel=2
AssertEqual synconcealed(1, 1)[0], 0
AssertEqual synconcealed(1, 2)[0], 0
AssertEqual synconcealed(1, 3)[0], 0
AssertEqual synconcealed(1, 4)[0], 0
AssertEqual synconcealed(1, 4)[0], 0
AssertEqual synconcealed(1, 5)[0], 0
AssertEqual synconcealed(1, 6)[0], 0
let g:vim_markdown_conceal=1
syn off | syn on
AssertEqual synconcealed(1, 1)[0], 1
AssertEqual synconcealed(1, 2)[0], 0
AssertEqual synconcealed(1, 3)[0], 1
AssertEqual synconcealed(1, 4)[0], 1
AssertEqual synconcealed(1, 4)[0], 1
AssertEqual synconcealed(1, 5)[0], 1
AssertEqual synconcealed(1, 6)[0], 1
setlocal conceallevel=0
unlet g:vim_markdown_conceal
syn off | syn on
endif
# Autolinks
Given markdown;
a <http://b> c
Execute (autolink):
AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
AssertEqual SyntaxOf('<'), 'mkdDelimiter'
AssertEqual SyntaxOf('b'), 'mkdInlineURL'
AssertEqual SyntaxOf('>'), 'mkdDelimiter'
AssertNotEqual SyntaxOf('c'), 'mkdInlineURL'
Given markdown;
http://12monkeys.foo
Execute (autolink with domain starting with a number):
AssertEqual SyntaxOf('12monkeys'), 'mkdInlineURL'
Given markdown;
<HtTp://a>
Execute (autolink with scheme case is insensitive):
AssertEqual SyntaxOf('a'), 'mkdInlineURL'
Given markdown;
<a>
Execute (autolink without scheme is not a link):
AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
Given markdown;
< http://a >
<http://b c>
<http://d
e>
Execute (autolink with space is not a link):
AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
AssertNotEqual SyntaxOf('b'), 'mkdInlineURL'
AssertNotEqual SyntaxOf('c'), 'mkdInlineURL'
AssertNotEqual SyntaxOf('d'), 'mkdInlineURL'
AssertNotEqual SyntaxOf('e'), 'mkdInlineURL'
Given markdown;
\<http://a>
Execute (autolinks can be backslash escaped):
AssertNotEqual SyntaxOf('<'), 'mkdDelimiter'
Given markdown;
a (http://b.bb) c
Execute (autolink in parenthesis):
AssertNotEqual SyntaxOf('a'), 'mkdInlineURL'
AssertEqual SyntaxOf('('), 'mkdDelimiter'
AssertEqual SyntaxOf('b'), 'mkdInlineURL'
AssertEqual SyntaxOf(')'), 'mkdDelimiter'
AssertNotEqual SyntaxOf('c'), 'mkdInlineURL'
Given markdown;
[![a](http://b)](http://c)
Execute (autolink in link text):
AssertEqual SyntaxOf('!'), 'mkdDelimiter'
AssertEqual SyntaxOf('a'), 'mkdLink'
AssertEqual SyntaxOf('b'), 'mkdURL'
AssertEqual SyntaxOf('c'), 'mkdURL'
Given markdown;
# [h1link](url)
## [h2link](url)
### [h3link](url)
#### [h4link](url)
##### [h5link](url)
###### [h6link](url)
[h1link_b](url)
===============
[h2link_b](url)
---------------
Execute (link in headers):
AssertEqual SyntaxOf('h1link'), 'mkdLink'
AssertEqual SyntaxOf('h2link'), 'mkdLink'
AssertEqual SyntaxOf('h3link'), 'mkdLink'
AssertEqual SyntaxOf('h4link'), 'mkdLink'
AssertEqual SyntaxOf('h5link'), 'mkdLink'
AssertEqual SyntaxOf('h6link'), 'mkdLink'
AssertEqual SyntaxOf('h1link_b'), 'mkdLink'
AssertEqual SyntaxOf('h2link_b'), 'mkdLink'
Given markdown;
# http://h1link.foo
## http://h2link.foo
### http://h3link.foo
#### http://h4link.foo
##### http://h5link.foo
###### http://h6link.foo
http://h1link_b.foo
===================
http://h2link_b.foo
-------------------
Execute (inline url in headers):
AssertEqual SyntaxOf('h1link'), 'mkdInlineURL'
AssertEqual SyntaxOf('h2link'), 'mkdInlineURL'
AssertEqual SyntaxOf('h3link'), 'mkdInlineURL'
AssertEqual SyntaxOf('h4link'), 'mkdInlineURL'
AssertEqual SyntaxOf('h5link'), 'mkdInlineURL'
AssertEqual SyntaxOf('h6link'), 'mkdInlineURL'
AssertEqual SyntaxOf('h1link_b'), 'mkdInlineURL'
AssertEqual SyntaxOf('h2link_b'), 'mkdInlineURL'
Given markdown;
> [a](b)
> http://foo.bar
Execute (link in blockquote):
AssertEqual SyntaxOf('a'), 'mkdLink'
AssertEqual SyntaxOf('foo'), 'mkdInlineURL'
Given markdown;
[https://domain.tld](https://domain.com) not_a_link
Execute (link with url title):
AssertEqual SyntaxOf('https://domain.tld'), 'mkdInlineURL'
Updated plugins
2020-06-21 11:50:44 -04:00
AssertNotEqual SyntaxOf(']'), 'mkdInlineURL'
AssertEqual SyntaxOf('https://domain.com'), 'mkdURL'
Updated plugins and added vim-markdown
2018-02-04 06:35:08 -05:00
AssertNotEqual SyntaxOf('not_a_link'), 'mkdInlineURL'
# Code Blocks
Given markdown;
~~~
code
~~~
Execute (code blocks can be fenced with tildes):
AssertEqual SyntaxOf('c'), 'mkdCode'
Given markdown;
~~~~
code
~~~~~
Execute (code blocks can be fenced with tildes longer than 3):
AssertEqual SyntaxOf('c'), 'mkdCode'
Given markdown;
````
code
`````
Execute (code blocks can be fenced with backticks longer than 3):
AssertEqual SyntaxOf('c'), 'mkdCode'
Given markdown;
~~~ruby
code
~~~
Execute (code blocks can have a language specifier):
AssertEqual SyntaxOf('c'), 'mkdCode'
Given markdown;
```c++
code
```
text
Execute (code blocks can be fenced with backticks and a language specifier):
AssertEqual SyntaxOf('code'), 'mkdCode'
AssertNotEqual SyntaxOf('text'), 'mkdCode'
# Indent Code Blocks
Given markdown;
a
b
c
Execute (indent code blocks):
AssertNotEqual SyntaxOf('a'), 'mkdCode'
AssertEqual SyntaxOf('b'), 'mkdCode'
AssertEqual SyntaxOf('c'), 'mkdCode'
Given markdown;
# a
b
c
Execute (indent code blocks after header):
AssertNotEqual SyntaxOf('a'), 'mkdCode'
AssertNotEqual SyntaxOf('b'), 'mkdCode'
AssertEqual SyntaxOf('c'), 'mkdCode'
Given markdown;
- a
b
c
Execute (indent code blocks after list):
AssertNotEqual SyntaxOf('a'), 'mkdCode'
AssertNotEqual SyntaxOf('b'), 'mkdCode'
AssertEqual SyntaxOf('c'), 'mkdCode'
Given markdown;
a
b
Execute (indent code block at beginning of file):
AssertEqual SyntaxOf('a'), 'mkdCode'
AssertEqual SyntaxOf('b'), 'mkdCode'
Given markdown;
```c++
#include <iostream>
code
```
```ruby
def a
end
```
Updated plugins
2020-12-04 16:15:32 -05:00
```ruby {linenos=table,hl_lines=[8,"15-17"],linenostart=199}
class b
end
```
Updated plugins and added vim-markdown
2018-02-04 06:35:08 -05:00
Execute (fenced code block syntax with a language specifier):
let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
call b:func(0)
AssertEqual SyntaxOf('include'), 'cInclude'
AssertEqual SyntaxOf('code'), 'mkdSnippetCPP'
AssertEqual SyntaxOf('def'), 'rubyDefine'
Updated plugins
2020-12-04 16:15:32 -05:00
AssertEqual SyntaxOf('class'), 'rubyClass'
Updated plugins and added vim-markdown
2018-02-04 06:35:08 -05:00
Given markdown;
``` c++
#include <iostream>
code
```
``` vim
let g:a = 1
```
``` ruby
def a
end
```
```
ruby
class B
end
```
Execute (fenced code block syntax with a language specifier after whitespace):
let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
call b:func(0)
AssertEqual SyntaxOf('include'), 'cInclude'
AssertEqual SyntaxOf('code'), 'mkdSnippetCPP'
AssertEqual SyntaxOf('g:a'), 'vimVar'
AssertEqual SyntaxOf('def'), 'rubyDefine'
AssertNotEqual SyntaxOf('class'), 'rubyClass'
Given markdown;
```vim
let g:a = 1
```
```viml
let g:b = 1
```
Execute (fenced code block syntax with alias language specifier):
let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
call b:func(0)
AssertEqual SyntaxOf('g:a'), 'vimVar'
AssertEqual SyntaxOf('g:b'), 'vimVar'
Given markdown;
```csharp
var s = "foo";
```
Execute (fenced code block languages setting):
let g:vim_markdown_fenced_languages = ['csharp=cs']
source ../ftplugin/markdown.vim
let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
call b:func(0)
AssertEqual SyntaxOf('foo'), 'csString'
unlet g:vim_markdown_fenced_languages
Given markdown;
```vim
let g:a = 1
```
Execute (fenced code block includes language syntax with reopening same buffer):
let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
call b:func(0)
split
quit
edit
set filetype=markdown
execute "normal! i```vim\<cr>let g:a = 1\<cr>```"
call b:func(1)
AssertEqual SyntaxOf('g:a'), 'vimVar'
Given markdown;
```a+b-
code
```
Execute (fenced code block syntax with an unknown language specifier):
let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
call b:func(0)
AssertEqual SyntaxOf('code'), 'mkdSnippetA_B_'
Given markdown;
```
=
a
-
```
Execute (first = or - in fenced code block is not setex headers):
AssertEqual SyntaxOf('='), 'mkdCode'
AssertEqual SyntaxOf('-'), 'mkdCode'
Given markdown;
``` {style=""}
a
```
Execute (fenced code block with extended info strings):
AssertEqual SyntaxOf('a'), 'mkdCode'
Updated vim plugins
2022-12-03 05:29:32 -05:00
Given liquid;
```vim
let g:a = 1
```
Execute (fenced code block syntax in liquid file with markdown subtype):
let b:liquid_subtype = 'markdown'
let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
call b:func(0)
AssertEqual SyntaxOf('g:a'), 'vimVar'
Updated plugins and added vim-markdown
2018-02-04 06:35:08 -05:00
# Code Blocks in pre and code tag
Given markdown;
<pre>
a
</pre>
Execute (code block in pre tag):
AssertEqual SyntaxOf('a'), 'mkdCode'
Given markdown;
<code>
a
</code>
Execute (code block in code tag):
AssertEqual SyntaxOf('a'), 'mkdCode'
Given markdown;
\<pre\>
a
\</pre\>
Execute (not code block in escaped pre tag):
AssertNotEqual SyntaxOf('a'), 'mkdCode'
Given markdown;
\<code\>
a
\</code\>
Execute (not code block in escaped code tag):
AssertNotEqual SyntaxOf('a'), 'mkdCode'
Updated plugins
2019-03-08 06:04:56 -05:00
# Code quotes
Given markdown;
`a`
Execute (code in code quotes):
AssertEqual SyntaxOf('a'), 'mkdCode'
Given markdown;
`a\` b `c\` d
Execute (code quotes not escaped ending with backslash):
AssertEqual SyntaxOf('a\'), 'mkdCode'
AssertNotEqual SyntaxOf('b'), 'mkdCode'
AssertEqual SyntaxOf('c\'), 'mkdCode'
AssertNotEqual SyntaxOf('d'), 'mkdCode'
Updated plugins
2019-05-17 10:09:13 -04:00
Given markdown;
``a\`` b ``c`\`1`` d
Execute (double code quotes not escaped ending with backslash):
AssertEqual SyntaxOf('a\'), 'mkdCode'
AssertNotEqual SyntaxOf('b'), 'mkdCode'
AssertEqual SyntaxOf('c`\\`1'), 'mkdCode'
AssertNotEqual SyntaxOf('d'), 'mkdCode'
Updated plugins and added vim-markdown
2018-02-04 06:35:08 -05:00
# Math
Given markdown;
a $x$ b
c $$y$$ d
\$e\$
\$\$f\$\$
Execute (math):
AssertNotEqual SyntaxOf('x')[0:2], 'tex'
AssertNotEqual SyntaxOf('y')[0:2], 'tex'
let g:vim_markdown_math=1
syn off | syn on
AssertNotEqual SyntaxOf('a')[0:2], 'tex'
AssertNotEqual SyntaxOf('b')[0:2], 'tex'
AssertNotEqual SyntaxOf('c')[0:2], 'tex'
AssertNotEqual SyntaxOf('d')[0:2], 'tex'
AssertNotEqual SyntaxOf('e')[0:2], 'tex'
AssertNotEqual SyntaxOf('f')[0:2], 'tex'
AssertEqual SyntaxOf('x')[0:2], 'tex'
AssertEqual SyntaxOf('y')[0:2], 'tex'
let g:vim_markdown_math=0
syn off | syn on
AssertNotEqual SyntaxOf('x')[0:2], 'tex'
AssertNotEqual SyntaxOf('y')[0:2], 'tex'
Given markdown;
a
$
b
$
c
Execute (multiline math):
let g:vim_markdown_math=1
syn off | syn on
AssertNotEqual SyntaxOf('a')[0:2], 'tex'
AssertEqual SyntaxOf('b')[0:2], 'tex'
AssertNotEqual SyntaxOf('c')[0:2], 'tex'
Given markdown;
$ \sqrt{a}{b} $
$$ \frac{a}{b} $$
Execute (math tex highlighting):
let g:vim_markdown_math=0
syn off | syn on
Updated plugins
2020-12-04 16:15:32 -05:00
AssertNotEqual SyntaxOf('sqrt')[0:2], 'tex'
AssertNotEqual SyntaxOf('frac')[0:2], 'tex'
Updated plugins and added vim-markdown
2018-02-04 06:35:08 -05:00
let g:vim_markdown_math=1
syn off | syn on
Updated plugins
2020-12-04 16:15:32 -05:00
AssertEqual SyntaxOf('sqrt')[0:2], 'tex'
AssertEqual SyntaxOf('frac')[0:2], 'tex'
Updated plugins and added vim-markdown
2018-02-04 06:35:08 -05:00
Given markdown;
$a b[$ c
Execute (math ends with $):
let g:vim_markdown_math=1
syn off | syn on
AssertEqual SyntaxOf('a')[0:2], 'tex'
AssertEqual SyntaxOf('b')[0:2], 'tex'
AssertNotEqual SyntaxOf('c')[0:2], 'tex'
Given markdown;
$$a b[$$ c
Execute (math ends with $$):
let g:vim_markdown_math=1
syn off | syn on
AssertEqual SyntaxOf('a')[0:2], 'tex'
AssertEqual SyntaxOf('b')[0:2], 'tex'
AssertNotEqual SyntaxOf('c')[0:2], 'tex'
Given markdown;
Updated plugins
2020-12-04 16:15:32 -05:00
$(0 \leq 1)$
Updated plugins and added vim-markdown
2018-02-04 06:35:08 -05:00
Execute (math conceal in $):
if has('conceal')
setlocal conceallevel=2
let g:vim_markdown_math=1
syn off | syn on
AssertEqual synconcealed(1, 1)[0], 1, '$'
AssertEqual synconcealed(1, 2)[0], 0
AssertEqual synconcealed(1, 3)[0], 0
AssertEqual synconcealed(1, 4)[0], 0
Updated plugins
2020-12-04 16:15:32 -05:00
AssertEqual synconcealed(1, 5)[0], 1, '\leq'
Updated plugins and added vim-markdown
2018-02-04 06:35:08 -05:00
AssertEqual synconcealed(1, 6)[0], 1
AssertEqual synconcealed(1, 7)[0], 1
Updated plugins
2020-12-04 16:15:32 -05:00
AssertEqual synconcealed(1, 8)[0], 1
Updated plugins and added vim-markdown
2018-02-04 06:35:08 -05:00
AssertEqual synconcealed(1, 9)[0], 0
AssertEqual synconcealed(1, 10)[0], 0
Updated plugins
2020-12-04 16:15:32 -05:00
AssertEqual synconcealed(1, 11)[0], 0
AssertEqual synconcealed(1, 12)[0], 1, '$'
Updated plugins and added vim-markdown
2018-02-04 06:35:08 -05:00
setlocal conceallevel=0
endif
Given markdown;
$$
\omega
Updated plugins
2020-12-04 16:15:32 -05:00
0 \leq 1
Updated plugins and added vim-markdown
2018-02-04 06:35:08 -05:00
$$
Execute (math conceal in $$):
if has('conceal')
setlocal conceallevel=2
let g:vim_markdown_math=1
syn off | syn on
AssertEqual synconcealed(1, 1)[0], 1, '$$'
AssertEqual synconcealed(2, 1)[0], 1, '\omega'
AssertEqual synconcealed(3, 1)[0], 0, '0'
Updated plugins
2020-12-04 16:15:32 -05:00
AssertEqual synconcealed(3, 3)[0], 1, '\leq'
AssertEqual synconcealed(3, 8)[0], 0, '1'
Updated plugins and added vim-markdown
2018-02-04 06:35:08 -05:00
AssertEqual synconcealed(4, 1)[0], 1, '$$'
setlocal conceallevel=0
endif
# YAML frontmatter
Given markdown;
---
a: b
---
Execute (YAML frontmatter is controlled by the option):
AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
let g:vim_markdown_frontmatter=1
syn off | syn on
AssertEqual SyntaxOf('a')[0:3], 'yaml'
let g:vim_markdown_frontmatter=0
syn off | syn on
AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
Given markdown;
---
a: b
---
Execute (YAML frontmatter only works if it's the first thing in the file):
let g:vim_markdown_frontmatter=1
syn off | syn on
AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
Given markdown;
---
a: b
---
---
Execute (rules are not mistaken by YAML frontmatter delimiters):
let g:vim_markdown_frontmatter=1
syn off | syn on
AssertEqual SyntaxAt(5, 1), 'mkdRule'
unlet g:vim_markdown_frontmatter
# TOML frontmatter
Given markdown;
+++
a = "b"
+++
Execute (TOML frontmatter is controlled by the option):
syn off | syn on
AssertNotEqual SyntaxOf('b'), 'tomlString'
let g:vim_markdown_toml_frontmatter=1
syn off | syn on
AssertEqual SyntaxOf('b'), 'tomlString'
let g:vim_markdown_toml_frontmatter=0
syn off | syn on
AssertNotEqual SyntaxOf('b'), 'tomlString'
Given markdown;
+++
a = "b"
+++
Execute (TOML frontmatter only works if it's the first thing in the file):
let g:vim_markdown_toml_frontmatter=1
syn off | syn on
AssertNotEqual SyntaxOf('b'), 'tomlString'
unlet g:vim_markdown_toml_frontmatter
# JSON frontmatter
Given markdown;
{
"a": "b"
}
Execute (JSON frontmatter is controlled by the option):
syn off | syn on
AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
let g:vim_markdown_json_frontmatter=1
syn off | syn on
AssertEqual SyntaxOf('a'), 'jsonKeyword'
let g:vim_markdown_json_frontmatter=0
syn off | syn on
AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
Given markdown;
{
"a": "b"
}
Execute (JSON frontmatter only works if it's the first thing in the file):
let g:vim_markdown_json_frontmatter=1
syn off | syn on
AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
unlet g:vim_markdown_json_frontmatter
# Header
Given markdown;
# #a
ccc
## #b
ddd
Execute (header title starts with #):
AssertEqual SyntaxOf('a'), 'htmlH1'
AssertEqual SyntaxOf('b'), 'htmlH2'
Given markdown;
# h1 space
#h1 nospace
# h1 2 spaces
# h1 trailing hash #
## h2 space
##h2 nospace
## h2 trailing hash ##
### h3 space
###h3 nospace
### h3 trailing hash ###
#### h4
##### h5
###### h6
Execute (atx headers):
Updated plugins
2018-07-30 17:18:16 -04:00
AssertEqual SyntaxOf(' h1 space'), 'htmlH1'
AssertEqual SyntaxOf('h1 nospace'), 'htmlH1'
AssertEqual SyntaxOf(' h1 2 spaces'), 'htmlH1'
AssertEqual SyntaxOf(' h1 trailing hash '), 'htmlH1'
AssertEqual SyntaxOf(' h2 space'), 'htmlH2'
AssertEqual SyntaxOf('h2 nospace'), 'htmlH2'
AssertEqual SyntaxOf(' h2 trailing hash '), 'htmlH2'
AssertEqual SyntaxOf(' h3 space'), 'htmlH3'
AssertEqual SyntaxOf('h3 nospace'), 'htmlH3'
AssertEqual SyntaxOf(' h3 trailing hash '), 'htmlH3'
AssertEqual SyntaxOf(' h4'), 'htmlH4'
AssertEqual SyntaxOf(' h5'), 'htmlH5'
AssertEqual SyntaxOf(' h6'), 'htmlH6'
Updated plugins and added vim-markdown
2018-02-04 06:35:08 -05:00
Given markdown;
# h1 before h2
## h2 between h1s
# h1 after h2
Execute (atx headers relative positions):
Updated plugins
2018-07-30 17:18:16 -04:00
AssertEqual SyntaxOf(' h1 before h2'), 'htmlH1'
AssertEqual SyntaxOf(' h2 between h1s'), 'htmlH2'
AssertEqual SyntaxOf(' h1 after h2'), 'htmlH1'
Updated plugins and added vim-markdown
2018-02-04 06:35:08 -05:00
Given markdown;
setex h1
========
setex h2
--------
setex h1 single punctuation
=
setex h1 punctuation longer than header
================================
Execute (setex headers):
AssertEqual SyntaxOf('setex h1'), 'htmlH1'
AssertEqual SyntaxOf('^========$'), 'htmlH1'
AssertEqual SyntaxOf('setex h2'), 'htmlH2'
AssertEqual SyntaxOf('--------'), 'htmlH2'
AssertEqual SyntaxOf('setex h1 single punctuation'), 'htmlH1'
AssertEqual SyntaxOf('^=$'), 'htmlH1'
AssertEqual SyntaxOf('setex h1 punctuation longer than header'), 'htmlH1'
AssertEqual SyntaxOf('^================================$'), 'htmlH1'
Given markdown;
- not Setex
- because list
Execute (prevent list vs Setex confusion):
AssertNotEqual SyntaxOf('- not Setex'), 'htmlH2'
AssertNotEqual SyntaxOf('- becuase list'), 'htmlH2'
Given markdown;
setex h1 before atx
===================
## atx h2
### atx h3
# atx h1
setex h2
------------------
### atx h3 2
Execute (mixed atx and setex headers):
AssertEqual SyntaxOf('setex h1 before atx'), 'htmlH1'
AssertEqual SyntaxOf('==================='), 'htmlH1'
Updated plugins
2018-07-30 17:18:16 -04:00
AssertEqual SyntaxOf(' atx h2'), 'htmlH2'
AssertEqual SyntaxOf(' atx h3'), 'htmlH3'
AssertEqual SyntaxOf(' atx h1'), 'htmlH1'
Updated plugins and added vim-markdown
2018-02-04 06:35:08 -05:00
AssertEqual SyntaxOf('setex h2'), 'htmlH2'
AssertEqual SyntaxOf('------------------'), 'htmlH2'
# List
Given markdown;
- a & b
1. c > d
Execute (& and > are not marked as htmlError in lists):
AssertEqual SyntaxOf('-'), 'mkdListItem'
AssertEqual SyntaxOf('1.'), 'mkdListItem'
AssertNotEqual SyntaxOf('&'), 'htmlError'
AssertNotEqual SyntaxOf('>'), 'htmlError'
Given markdown;
1. a
2. b
Execute (list after line break):
AssertEqual SyntaxOf('1'), 'mkdListItem'
AssertEqual SyntaxOf('2'), 'mkdListItem'
# HTML
Given markdown;
a
<p>b</p>
- <span>c</span>
Execute (HTML tag in text):
AssertEqual SyntaxOf('p'), 'htmlTagName'
AssertEqual SyntaxOf('<p>'), 'htmlTag'
AssertEqual SyntaxOf('</p>'), 'htmlEndTag'
AssertEqual SyntaxOf('span'), 'htmlTagName'
AssertEqual SyntaxOf('<span>'), 'htmlTag'
AssertEqual SyntaxOf('</span>'), 'htmlEndTag'
Updated plugins
2024-01-07 10:14:20 -05:00
Given markdown;
# _h1_
## _h2_
### _h3_
#### _h4_
##### _h5_
###### _h6_
Execute (underscore italic text in atx headings):
AssertEqual SyntaxOf('h1'), 'htmlItalic'
AssertEqual SyntaxOf('h2'), 'htmlItalic'
AssertEqual SyntaxOf('h3'), 'htmlItalic'
AssertEqual SyntaxOf('h4'), 'htmlItalic'
AssertEqual SyntaxOf('h5'), 'htmlItalic'
AssertEqual SyntaxOf('h6'), 'htmlItalic'
Given markdown;
# *h1*
## *h2*
### *h3*
#### *h4*
##### *h5*
###### *h6*
Execute (asterisk italic text in atx headings):
AssertEqual SyntaxOf('h1'), 'htmlItalic'
AssertEqual SyntaxOf('h2'), 'htmlItalic'
AssertEqual SyntaxOf('h3'), 'htmlItalic'
AssertEqual SyntaxOf('h4'), 'htmlItalic'
AssertEqual SyntaxOf('h5'), 'htmlItalic'
AssertEqual SyntaxOf('h6'), 'htmlItalic'
Given markdown;
_h1_
=
_h2_
-
Execute (underscore italic text in setext headings):
AssertEqual SyntaxOf('h1'), 'htmlItalic'
AssertEqual SyntaxOf('h2'), 'htmlItalic'
Given markdown;
*h1*
=
*h2*
-
Execute (asterisk italic text in setext headings):
AssertEqual SyntaxOf('h1'), 'htmlItalic'
AssertEqual SyntaxOf('h2'), 'htmlItalic'
Given markdown;
# __h1__
## __h2__
### __h3__
#### __h4__
##### __h5__
###### __h6__
Execute (underscore bold text in atx headings):
AssertEqual SyntaxOf('h1'), 'htmlBold'
AssertEqual SyntaxOf('h2'), 'htmlBold'
AssertEqual SyntaxOf('h3'), 'htmlBold'
AssertEqual SyntaxOf('h4'), 'htmlBold'
AssertEqual SyntaxOf('h5'), 'htmlBold'
AssertEqual SyntaxOf('h6'), 'htmlBold'
Given markdown;
# **h1**
## **h2**
### **h3**
#### **h4**
##### **h5**
###### **h6**
Execute (asterisk bold text in atx headings):
AssertEqual SyntaxOf('h1'), 'htmlBold'
AssertEqual SyntaxOf('h2'), 'htmlBold'
AssertEqual SyntaxOf('h3'), 'htmlBold'
AssertEqual SyntaxOf('h4'), 'htmlBold'
AssertEqual SyntaxOf('h5'), 'htmlBold'
AssertEqual SyntaxOf('h6'), 'htmlBold'
Given markdown;
__h1__
=
__h2__
-
Execute (underscore bold text in setext headings):
AssertEqual SyntaxOf('h1'), 'htmlBold'
AssertEqual SyntaxOf('h2'), 'htmlBold'
Given markdown;
**h1**
=
**h2**
-
Execute (asterisk bold text in setext headings):
AssertEqual SyntaxOf('h1'), 'htmlBold'
AssertEqual SyntaxOf('h2'), 'htmlBold'
Given markdown;
# ___h1___
## ___h2___
### ___h3___
#### ___h4___
##### ___h5___
###### ___h6___
Execute (underscore bold italic text in atx headings):
AssertEqual SyntaxOf('h1'), 'htmlBoldItalic'
AssertEqual SyntaxOf('h2'), 'htmlBoldItalic'
AssertEqual SyntaxOf('h3'), 'htmlBoldItalic'
AssertEqual SyntaxOf('h4'), 'htmlBoldItalic'
AssertEqual SyntaxOf('h5'), 'htmlBoldItalic'
AssertEqual SyntaxOf('h6'), 'htmlBoldItalic'
Given markdown;
# ***h1***
## ***h2***
### ***h3***
#### ***h4***
##### ***h5***
###### ***h6***
Execute (asterisk bold italic text in atx headings):
AssertEqual SyntaxOf('h1'), 'htmlBoldItalic'
AssertEqual SyntaxOf('h2'), 'htmlBoldItalic'
AssertEqual SyntaxOf('h3'), 'htmlBoldItalic'
AssertEqual SyntaxOf('h4'), 'htmlBoldItalic'
AssertEqual SyntaxOf('h5'), 'htmlBoldItalic'
AssertEqual SyntaxOf('h6'), 'htmlBoldItalic'
Given markdown;
___h1___
=
___h2___
-
Execute (underscore bold italic text in setext headings):
AssertEqual SyntaxOf('h1'), 'htmlBoldItalic'
AssertEqual SyntaxOf('h2'), 'htmlBoldItalic'
Given markdown;
***h1***
=
***h2***
-
Execute (asterisk bold italic text in setext headings):
AssertEqual SyntaxOf('h1'), 'htmlBoldItalic'
AssertEqual SyntaxOf('h2'), 'htmlBoldItalic'
Given markdown;
# [^h1]
## [^h2]
### [^h3]
#### [^h4]
##### [^h5]
###### [^h6]
Execute (footnotes in atx headings):
AssertEqual SyntaxOf('h1'), 'mkdFootnotes'
AssertEqual SyntaxOf('h2'), 'mkdFootnotes'
AssertEqual SyntaxOf('h3'), 'mkdFootnotes'
AssertEqual SyntaxOf('h4'), 'mkdFootnotes'
AssertEqual SyntaxOf('h5'), 'mkdFootnotes'
AssertEqual SyntaxOf('h6'), 'mkdFootnotes'
Given markdown;
[^h1]
=
[^h2]
-
Execute (footnotes in setext headings):
AssertEqual SyntaxOf('h1'), 'mkdFootnotes'
AssertEqual SyntaxOf('h2'), 'mkdFootnotes'
Reference in a new issue Copy permalink