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'

# 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)

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

# 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://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'

# 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
```

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'

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;
```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'

# 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'

# Math

Given markdown;
a $x$ b
c $$y$$ d
\$e\$
\$\$f\$\$

Execute (math):
  AssertNotEqual SyntaxOf('x'), 'mkdMath'
  AssertNotEqual SyntaxOf('y'), 'mkdMath'
  let g:vim_markdown_math=1
  syn off | syn on
  AssertNotEqual SyntaxOf('a'), 'mkdMath'
  AssertNotEqual SyntaxOf('b'), 'mkdMath'
  AssertNotEqual SyntaxOf('c'), 'mkdMath'
  AssertNotEqual SyntaxOf('d'), 'mkdMath'
  AssertNotEqual SyntaxOf('e'), 'mkdMath'
  AssertNotEqual SyntaxOf('f'), 'mkdMath'
  AssertEqual SyntaxOf('x'), 'mkdMath'
  AssertEqual SyntaxOf('y'), 'mkdMath'
  let g:vim_markdown_math=0
  syn off | syn on
  AssertNotEqual SyntaxOf('x'), 'mkdMath'
  AssertNotEqual SyntaxOf('y'), 'mkdMath'

Given markdown;
a

$
b
$

c

Execute (multiline math):
  let g:vim_markdown_math=1
  syn off | syn on
  AssertNotEqual SyntaxOf('a'), 'mkdMath'
  AssertEqual SyntaxOf('b'), 'mkdMath'
  AssertNotEqual SyntaxOf('c'), 'mkdMath'

Given markdown;
$ \sqrt{a}{b} $
$$ \frac{a}{b} $$

Execute (math tex highlighting):
  let g:vim_markdown_math=0
  syn off | syn on
  AssertNotEqual SyntaxOf('sqrt'), 'texStatement'
  AssertNotEqual SyntaxOf('frac'), 'texStatement'
  let g:vim_markdown_math=1
  syn off | syn on
  AssertEqual SyntaxOf('sqrt'), 'texStatement'
  AssertEqual SyntaxOf('frac'), 'texStatement'

# 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):
  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'

Given markdown;
# h1 before h2

## h2 between h1s

# h1 after h2

Execute (atx headers relative positions):
  AssertEqual SyntaxOf('# h1 before h2'), 'htmlH1'
  AssertEqual SyntaxOf('## h2 between h1s'), 'htmlH2'
  AssertEqual SyntaxOf('# h1 after h2'), 'htmlH1'

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'
  AssertEqual SyntaxOf('## atx h2'), 'htmlH2'
  AssertEqual SyntaxOf('### atx h3'), 'htmlH3'
  AssertEqual SyntaxOf('# atx h1'), 'htmlH1'
  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'