// // Blackfriday Markdown Processor // Available at http://github.com/russross/blackfriday // // Copyright © 2011 Russ Ross . // Distributed under the Simplified BSD License. // See README.md for details. // // // Unit tests for inline parsing // package blackfriday import ( "regexp" "testing" "strings" ) func TestEmphasis(t *testing.T) { t.Parallel() var tests = []string{ "nothing inline\n", "

nothing inline

\n", "simple *inline* test\n", "

simple inline test

\n", "*at the* beginning\n", "

at the beginning

\n", "at the *end*\n", "

at the end

\n", "*try two* in *one line*\n", "

try two in one line

\n", "over *two\nlines* test\n", "

over two\nlines test

\n", "odd *number of* markers* here\n", "

odd number of markers* here

\n", "odd *number\nof* markers* here\n", "

odd number\nof markers* here

\n", "simple _inline_ test\n", "

simple inline test

\n", "_at the_ beginning\n", "

at the beginning

\n", "at the _end_\n", "

at the end

\n", "_try two_ in _one line_\n", "

try two in one line

\n", "over _two\nlines_ test\n", "

over two\nlines test

\n", "odd _number of_ markers_ here\n", "

odd number of markers_ here

\n", "odd _number\nof_ markers_ here\n", "

odd number\nof markers_ here

\n", "mix of *markers_\n", "

mix of *markers_

\n", "*What is A\\* algorithm?*\n", "

What is A* algorithm?

\n", } doTestsInline(t, tests) } func TestReferenceOverride(t *testing.T) { t.Parallel() var tests = []string{ "test [ref1][]\n", "

test ref1

\n", "test [my ref][ref1]\n", "

test my ref

\n", "test [ref2][]\n\n[ref2]: http://www.leftalone.com/ (Ref left alone)\n", "

test ref2

\n", "test [ref3][]\n\n[ref3]: http://www.leftalone.com/ (Ref left alone)\n", "

test ref3

\n", "test [ref4][]\n\n[ref4]: http://zombo.com/ (You can do anything)\n", "

test [ref4][]

\n", "test [!(*http.ServeMux).ServeHTTP][] complicated ref\n", "

test !(*http.ServeMux).ServeHTTP complicated ref

\n", "test [ref5][]\n", "

test Moo

\n", } doTestsInlineParam(t, tests, TestParams{ referenceOverride: func(reference string) (rv *Reference, overridden bool) { switch reference { case "ref1": // just an overridden reference exists without definition return &Reference{ Link: "http://www.ref1.com/", Title: "Reference 1"}, true case "ref2": // overridden exists and reference defined return &Reference{ Link: "http://www.overridden.com/", Title: "Reference Overridden"}, true case "ref3": // not overridden and reference defined return nil, false case "ref4": // overridden missing and defined return nil, true case "!(*http.ServeMux).ServeHTTP": return &Reference{ Link: "http://localhost:6060/pkg/net/http/#ServeMux.ServeHTTP", Title: "ServeHTTP docs"}, true case "ref5": return &Reference{ Link: "http://www.ref5.com/", Title: "Reference 5", Text: "Moo", }, true } return nil, false }, }) } func TestStrong(t *testing.T) { t.Parallel() var tests = []string{ "nothing inline\n", "

nothing inline

\n", "simple **inline** test\n", "

simple inline test

\n", "**at the** beginning\n", "

at the beginning

\n", "at the **end**\n", "

at the end

\n", "**try two** in **one line**\n", "

try two in one line

\n", "over **two\nlines** test\n", "

over two\nlines test

\n", "odd **number of** markers** here\n", "

odd number of markers** here

\n", "odd **number\nof** markers** here\n", "

odd number\nof markers** here

\n", "simple __inline__ test\n", "

simple inline test

\n", "__at the__ beginning\n", "

at the beginning

\n", "at the __end__\n", "

at the end

\n", "__try two__ in __one line__\n", "

try two in one line

\n", "over __two\nlines__ test\n", "

over two\nlines test

\n", "odd __number of__ markers__ here\n", "

odd number of markers__ here

\n", "odd __number\nof__ markers__ here\n", "

odd number\nof markers__ here

\n", "mix of **markers__\n", "

mix of **markers__

\n", "**`/usr`** : this folder is named `usr`\n", "

/usr : this folder is named usr

\n", "**`/usr`** :\n\n this folder is named `usr`\n", "

/usr :

\n\n

this folder is named usr

\n", } doTestsInline(t, tests) } func TestEmphasisMix(t *testing.T) { t.Parallel() var tests = []string{ "***triple emphasis***\n", "

triple emphasis

\n", "***triple\nemphasis***\n", "

triple\nemphasis

\n", "___triple emphasis___\n", "

triple emphasis

\n", "***triple emphasis___\n", "

***triple emphasis___

\n", "*__triple emphasis__*\n", "

triple emphasis

\n", "__*triple emphasis*__\n", "

triple emphasis

\n", "**improper *nesting** is* bad\n", "

improper *nesting is* bad

\n", "*improper **nesting* is** bad\n", "

*improper nesting* is bad

\n", } doTestsInline(t, tests) } func TestEmphasisLink(t *testing.T) { t.Parallel() var tests = []string{ "[first](before) *text[second] (inside)text* [third](after)\n", "

first textsecondtext third

\n", "*incomplete [link] definition*\n", "

incomplete [link] definition

\n", "*it's [emphasis*] (not link)\n", "

it's [emphasis] (not link)

\n", "*it's [emphasis*] and *[asterisk]\n", "

it's [emphasis] and *[asterisk]

\n", } doTestsInline(t, tests) } func TestStrikeThrough(t *testing.T) { t.Parallel() var tests = []string{ "nothing inline\n", "

nothing inline

\n", "simple ~~inline~~ test\n", "

simple ~~inline~~ test

\n", "~~at the~~ beginning\n", "

~~at the~~ beginning

\n", "at the ~~end~~\n", "

at the ~~end~~

\n", "~~try two~~ in ~~one line~~\n", "

~~try two~~ in ~~one line~~

\n", "over ~~two\nlines~~ test\n", "

over ~~two\nlines~~ test

\n", "odd ~~number of~~ markers~~ here\n", "

odd ~~number of~~ markers~~ here

\n", "odd ~~number\nof~~ markers~~ here\n", "

odd ~~number\nof~~ markers~~ here

\n", } doTestsInline(t, tests) } func TestCodeSpan(t *testing.T) { t.Parallel() var tests = []string{ "`source code`\n", "

source code

\n", "` source code with spaces `\n", "

source code with spaces

\n", "` source code with spaces `not here\n", "

source code with spacesnot here

\n", "a `single marker\n", "

a `single marker

\n", "a single multi-tick marker with ``` no text\n", "

a single multi-tick marker with ``` no text

\n", "markers with ` ` a space\n", "

markers with a space

\n", "`source code` and a `stray\n", "

source code and a `stray

\n", "`source *with* _awkward characters_ in it`\n", "

source *with* _awkward characters_ in it

\n", "`split over\ntwo lines`\n", "

split over\ntwo lines

\n", "```multiple ticks``` for the marker\n", "

multiple ticks for the marker

\n", "```multiple ticks `with` ticks inside```\n", "

multiple ticks `with` ticks inside

\n", } doTestsInline(t, tests) } func TestLineBreak(t *testing.T) { t.Parallel() var tests = []string{ "this line \nhas a break\n", "

this line
\nhas a break

\n", "this line \ndoes not\n", "

this line\ndoes not

\n", "this line\\\ndoes not\n", "

this line\\\ndoes not

\n", "this line\\ \ndoes not\n", "

this line\\\ndoes not

\n", "this has an \nextra space\n", "

this has an
\nextra space

\n", } doTestsInline(t, tests) tests = []string{ "this line \nhas a break\n", "

this line
\nhas a break

\n", "this line \ndoes not\n", "

this line\ndoes not

\n", "this line\\\nhas a break\n", "

this line
\nhas a break

\n", "this line\\ \ndoes not\n", "

this line\\\ndoes not

\n", "this has an \nextra space\n", "

this has an
\nextra space

\n", } doTestsInlineParam(t, tests, TestParams{ extensions: BackslashLineBreak}) } func TestInlineLink(t *testing.T) { t.Parallel() var tests = []string{ "[foo](/bar/)\n", "

foo

\n", "[foo with a title](/bar/ \"title\")\n", "

foo with a title

\n", "[foo with a title](/bar/\t\"title\")\n", "

foo with a title

\n", "[foo with a title](/bar/ \"title\" )\n", "

foo with a title

\n", "[foo with a title](/bar/ title with no quotes)\n", "

foo with a title

\n", "[foo]()\n", "

[foo]()

\n", "![foo](/bar/)\n", "

$\"foo\"$

\n", "![foo with a title](/bar/ \"title\")\n", "

$\"foo$

\n", "![foo with a title](/bar/\t\"title\")\n", "

$\"foo$

\n", "![foo with a title](/bar/ \"title\" )\n", "

$\"foo$

\n", "![foo with a title](/bar/ title with no quotes)\n", "

$\"foo$

\n", "![](img.jpg)\n", "

$\"\"$

\n", "[link](url)\n", "

link

\n", "![foo]()\n", "

![foo]()

\n", "[a link]\t(/with_a_tab/)\n", "

a link

\n", "[a link] (/with_spaces/)\n", "

a link

\n", "[text (with) [[nested] (brackets)]](/url/)\n", "

text (with) [[nested] (brackets)]

\n", "[text (with) [broken nested] (brackets)]](/url/)\n", "

[text (with) broken nested]](/url/)

\n", "[text\nwith a newline](/link/)\n", "

text\nwith a newline

\n", "[text in brackets] [followed](/by a link/)\n", "

[text in brackets] followed

\n", "[link with\\] a closing bracket](/url/)\n", "

link with] a closing bracket

\n", "[link with\\[ an opening bracket](/url/)\n", "

link with[ an opening bracket

\n", "[link with\\) a closing paren](/url/)\n", "

link with) a closing paren

\n", "[link with\\( an opening paren](/url/)\n", "

link with( an opening paren

\n", "[link]( with whitespace)\n", "

link

\n", "[link]( with whitespace )\n", "

link

\n", "[![image](someimage)](with image)\n", "

$\"image\"$

\n", "[link](url \"one quote)\n", "

link

\n", "[link](url 'one quote)\n", "

link

\n", "[link]()\n", "

link

\n", "[link & ampersand](/url/)\n", "

link & ampersand

\n", "[link & ampersand](/url/)\n", "

link & ampersand

\n", "[link](/url/&query)\n", "

link

\n", "[[t]](/t)\n", "

[t]

\n", "[link]()\n", "

link

\n", "[link](<./>)\n", "

link

\n", "[link](<../>)\n", "

link

\n", } doLinkTestsInline(t, tests) } func TestRelAttrLink(t *testing.T) { t.Parallel() var nofollowTests = []string{ "[foo](http://bar.com/foo/)\n", "

foo

\n", "[foo](/bar/)\n", "

foo

\n", "[foo](/)\n", "

foo

\n", "[foo](./)\n", "

foo

\n", "[foo](../)\n", "

foo

\n", "[foo](../bar)\n", "

foo

\n", } doTestsInlineParam(t, nofollowTests, TestParams{ HTMLFlags: Safelink | NofollowLinks, }) var noreferrerTests = []string{ "[foo](http://bar.com/foo/)\n", "

foo

\n", "[foo](/bar/)\n", "

foo

\n", } doTestsInlineParam(t, noreferrerTests, TestParams{ HTMLFlags: Safelink | NoreferrerLinks, }) var noopenerTests = []string{ "[foo](http://bar.com/foo/)\n", "

foo

\n", "[foo](/bar/)\n", "

foo

\n", } doTestsInlineParam(t, noopenerTests, TestParams{ HTMLFlags: Safelink | NoopenerLinks, }) var nofollownoreferrernoopenerTests = []string{ "[foo](http://bar.com/foo/)\n", "

foo

\n", "[foo](/bar/)\n", "

foo

\n", } doTestsInlineParam(t, nofollownoreferrernoopenerTests, TestParams{ HTMLFlags: Safelink | NofollowLinks | NoreferrerLinks | NoopenerLinks, }) } func TestHrefTargetBlank(t *testing.T) { t.Parallel() var tests = []string{ // internal link "[foo](/bar/)\n", "

foo

\n", "[foo](/)\n", "

foo

\n", "[foo](./)\n", "

foo

\n", "[foo](./bar)\n", "

foo

\n", "[foo](../)\n", "

foo

\n", "[foo](../bar)\n", "

foo

\n", "[foo](http://example.com)\n", "

foo

\n", } doTestsInlineParam(t, tests, TestParams{ HTMLFlags: Safelink | HrefTargetBlank, }) } func TestSafeInlineLink(t *testing.T) { t.Parallel() var tests = []string{ "[foo](/bar/)\n", "

foo

\n", "[foo](/)\n", "

foo

\n", "[foo](./)\n", "

foo

\n", "[foo](../)\n", "

foo

\n", "[foo](http://bar/)\n", "

foo

\n", "[foo](https://bar/)\n", "

foo

\n", "[foo](ftp://bar/)\n", "

foo

\n", "[foo](mailto://bar/)\n", "

foo

\n", // Not considered safe "[foo](baz://bar/)\n", "

foo

\n", } doSafeTestsInline(t, tests) } func TestReferenceLink(t *testing.T) { t.Parallel() var tests = []string{ "[link][ref]\n", "

[link][ref]

\n", "[link][ref]\n [ref]: /url/ \"title\"\n", "

link

\n", "[link][ref]\n [ref]: /url/\n", "

link

\n", " [ref]: /url/\n", "", " [ref]: /url/\n[ref2]: /url/\n [ref3]: /url/\n", "", " [ref]: /url/\n[ref2]: /url/\n [ref3]: /url/\n [4spaces]: /url/\n", "

[4spaces]: /url/\n

\n", "[hmm](ref2)\n [ref]: /url/\n[ref2]: /url/\n [ref3]: /url/\n", "

hmm

\n", "[ref]\n", "

[ref]

\n", "[ref]\n [ref]: /url/ \"title\"\n", "

ref

\n", "[ref]\n [ref]: ../url/ \"title\"\n", "

ref

\n", "[link][ref]\n [ref]: /url/", "

link

\n", } doLinkTestsInline(t, tests) } func TestTags(t *testing.T) { t.Parallel() var tests = []string{ "a tag\n", "

a tag

\n", "tag\n", "

tag

\n", "mismatch\n", "

mismatch

\n", "a tag\n", "

a tag

\n", } doTestsInline(t, tests) } func TestAutoLink(t *testing.T) { t.Parallel() var tests = []string{ "http://foo.com/\n", "

http://foo.com/

\n", "1 http://foo.com/\n", "

1 http://foo.com/

\n", "1http://foo.com/\n", "

1http://foo.com/

\n", "1.http://foo.com/\n", "

1.http://foo.com/

\n", "1. http://foo.com/\n", "

http://foo.com/

\n", "-http://foo.com/\n", "

-http://foo.com/

\n", "- http://foo.com/\n", "

http://foo.com/

\n", "_http://foo.com/\n", "

_http://foo.com/

\n", "令狐http://foo.com/\n", "

令狐http://foo.com/

\n", "令狐 http://foo.com/\n", "

令狐 http://foo.com/

\n", "ahttp://foo.com/\n", "

ahttp://foo.com/

\n", ">http://foo.com/\n", "

\n
http://foo.com/
\n

\n", "> http://foo.com/\n", "

\n
http://foo.com/
\n

\n", "go to \n", "

go to http://foo.com/

\n", "a secure \n", "

a secure https://link.org

\n", "an email \n", "

an email some@one.com

\n", "an email \n", "

an email some@one.com

\n", "an email \n", "

an email some@one.com

\n", "an ftp \n", "

an ftp ftp://old.com

\n", "an ftp \n", "

an ftp ftp:old.com

\n", "a link with \n", "

a link with " + "http://new.com?query=foo&bar

\n", "quotes mean a tag \n", "

quotes mean a tag

\n", "quotes mean a tag \n", "

quotes mean a tag

\n", "unless escaped \n", "

unless escaped " + "http://new.com?query="foo"&bar

\n", "even a > can be escaped &etc>\n", "

even a > can be escaped " + "http://new.com?q=>&etc

\n", "http://fancy.com\n", "

http://fancy.com

\n", "This is a link\n", "

This is a link

\n", "http://www.fancy.com/A_B.pdf\n", "

http://www.fancy.com/A_B.pdf

\n", "(http://www.fancy.com/A_B (\n", "

(http://www.fancy.com/A_B (

\n", "(http://www.fancy.com/A_B (part two: http://www.fancy.com/A_B)).\n", "

(http://www.fancy.com/A_B (part two: http://www.fancy.com/A_B)).

\n", "http://www.foo.com
\n", "

http://www.foo.com

\n", "http://foo.com/viewtopic.php?f=18&t=297", "

http://foo.com/viewtopic.php?f=18&t=297

\n", "http://foo.com/viewtopic.php?param="18"zz", "

http://foo.com/viewtopic.php?param="18"zz

\n", "http://foo.com/viewtopic.php?param="18"", "

http://foo.com/viewtopic.php?param="18"

\n", "https://fancy.com\n", "

https://fancy.com

\n", } doLinkTestsInline(t, tests) } var footnoteTests = []string{ "testing footnotes.[^a]\n\n[^a]: This is the note\n", `

testing footnotes.¹

This is the note

`, `testing long[^b] notes. [^b]: Paragraph 1 Paragraph 2 ` + "```\n\tsome code\n\t```" + ` Paragraph 3 No longer in the footnote `, `

testing long¹ notes.

No longer in the footnote

Paragraph 1

Paragraph 2

some code

Paragraph 3

`, `testing[^c] multiple[^d] notes. [^c]: this is [note] c omg [^d]: this is note d what happens here [note]: /link/c `, `

testing¹ multiple² notes.

omg

what happens here

this is note c
this is note d

`, "testing inline^[this is the note] notes.\n", `

testing inline¹ notes.

this is the note

`, "testing multiple[^1] types^[inline note] of notes[^2]\n\n[^2]: the second deferred note\n[^1]: the first deferred note\n\n\twhich happens to be a block\n", `

testing multiple¹ types² of notes³

the first deferred note

which happens to be a block
inline note
the second deferred note

`, `This is a footnote[^1]^[and this is an inline footnote] [^1]: the footnote text. may be multiple paragraphs. `, `

This is a footnote¹²

the footnote text.

may be multiple paragraphs.
and this is an inline footnote

`, "empty footnote[^]\n\n[^]: fn text", "

empty footnote¹

\n\n

fn text

\n\n

\n", "Some text.[^note1]\n\n[^note1]: fn1", "

Some text.¹

\n\n

\n", "Some text.[^note1][^note2]\n\n[^note1]: fn1\n[^note2]: fn2\n", "

Some text.¹²

\n\n

\n", `Bla bla [^1] [WWW][w3] [^1]: This is a footnote [w3]: http://www.w3.org/ `, `

Bla bla ¹ WWW

This is a footnote

`, `This is exciting![^fn1] [^fn1]: Fine print `, `

This is exciting!¹

Fine print

`, `This text does not reference a footnote. [^footnote]: But it has a footnote! And it gets omitted. `, "

This text does not reference a footnote.

\n", } func TestFootnotes(t *testing.T) { t.Parallel() doTestsInlineParam(t, footnoteTests, TestParams{ extensions: Footnotes, }) } func TestFootnotesWithParameters(t *testing.T) { t.Parallel() tests := make([]string, len(footnoteTests)) prefix := "testPrefix" returnText := "ret" re := regexp.MustCompile(`(?ms)

(.*?)

`) // Transform the test expectations to match the parameters we're using. for i, test := range footnoteTests { if i%2 == 1 { test = strings.Replace(test, "fn:", "fn:"+prefix, -1) test = strings.Replace(test, "fnref:", "fnref:"+prefix, -1) test = re.ReplaceAllString(test, `

$2 ret

`) } tests[i] = test } params := HTMLRendererParameters{ FootnoteAnchorPrefix: prefix, FootnoteReturnLinkContents: returnText, } doTestsInlineParam(t, tests, TestParams{ extensions: Footnotes, HTMLFlags: FootnoteReturnLinks, HTMLRendererParameters: params, }) } func TestNestedFootnotes(t *testing.T) { t.Parallel() var tests = []string{ `Paragraph.[^fn1] [^fn1]: Asterisk[^fn2] [^fn2]: Obelisk`, `

Paragraph.¹

Asterisk²
Obelisk

`, } doTestsInlineParam(t, tests, TestParams{extensions: Footnotes}) } func TestInlineComments(t *testing.T) { t.Parallel() var tests = []string{ "Hello \n", "

Hello

\n", "Hello ", "

Hello

\n", "Hello \n", "

Hello

\n", "Hello \na", "

Hello \na

\n", "* list \n", "

list

\n", " comment\n", "

comment

\n", "blahblah\n\nrhubarb\n", "

blahblah\n\nrhubarb

\n", } doTestsInlineParam(t, tests, TestParams{HTMLFlags: Smartypants | SmartypantsDashes}) } func TestSmartDoubleQuotes(t *testing.T) { t.Parallel() var tests = []string{ "this should be normal \"quoted\" text.\n", "

this should be normal “quoted” text.

\n", "this \" single double\n", "

this “ single double

\n", "two pair of \"some\" quoted \"text\".\n", "

two pair of “some” quoted “text”.

\n"} doTestsInlineParam(t, tests, TestParams{HTMLFlags: Smartypants}) } func TestSmartDoubleQuotesNBSP(t *testing.T) { t.Parallel() var tests = []string{ "this should be normal \"quoted\" text.\n", "

this should be normal “ quoted ” text.

\n", "this \" single double\n", "

this “ single double

\n", "two pair of \"some\" quoted \"text\".\n", "

two pair of “ some ” quoted “ text ”.

\n"} doTestsInlineParam(t, tests, TestParams{HTMLFlags: Smartypants | SmartypantsQuotesNBSP}) } func TestSmartAngledDoubleQuotes(t *testing.T) { t.Parallel() var tests = []string{ "this should be angled \"quoted\" text.\n", "

this should be angled «quoted» text.

\n", "this \" single double\n", "

this « single double

\n", "two pair of \"some\" quoted \"text\".\n", "

two pair of «some» quoted «text».

\n"} doTestsInlineParam(t, tests, TestParams{HTMLFlags: Smartypants | SmartypantsAngledQuotes}) } func TestSmartAngledDoubleQuotesNBSP(t *testing.T) { t.Parallel() var tests = []string{ "this should be angled \"quoted\" text.\n", "

this should be angled « quoted » text.

\n", "this \" single double\n", "

this « single double

\n", "two pair of \"some\" quoted \"text\".\n", "

two pair of « some » quoted « text ».

\n"} doTestsInlineParam(t, tests, TestParams{HTMLFlags: Smartypants | SmartypantsAngledQuotes | SmartypantsQuotesNBSP}) } func TestSmartFractions(t *testing.T) { t.Parallel() var tests = []string{ "1/2, 1/4 and 3/4; 1/4th and 3/4ths\n", "

½, ¼ and ¾; ¼th and ¾ths

\n", "1/2/2015, 1/4/2015, 3/4/2015; 2015/1/2, 2015/1/4, 2015/3/4.\n", "

1/2/2015, 1/4/2015, 3/4/2015; 2015/1/2, 2015/1/4, 2015/3/4.

\n"} doTestsInlineParam(t, tests, TestParams{HTMLFlags: Smartypants}) tests = []string{ "1/2, 2/3, 81/100 and 1000000/1048576.\n", "

¹⁄₂, ²⁄₃, ⁸¹⁄₁₀₀ and ^1000000⁄_1048576.

\n", "1/2/2015, 1/4/2015, 3/4/2015; 2015/1/2, 2015/1/4, 2015/3/4.\n", "

1/2/2015, 1/4/2015, 3/4/2015; 2015/1/2, 2015/1/4, 2015/3/4.

\n"} doTestsInlineParam(t, tests, TestParams{HTMLFlags: Smartypants | SmartypantsFractions}) } func TestDisableSmartDashes(t *testing.T) { t.Parallel() doTestsInlineParam(t, []string{ "foo - bar\n", "

foo - bar

\n", "foo -- bar\n", "

foo -- bar

\n", "foo --- bar\n", "

foo --- bar

\n", }, TestParams{}) doTestsInlineParam(t, []string{ "foo - bar\n", "

foo – bar

\n", "foo -- bar\n", "

foo — bar

\n", "foo --- bar\n", "

foo —– bar

\n", }, TestParams{HTMLFlags: Smartypants | SmartypantsDashes}) doTestsInlineParam(t, []string{ "foo - bar\n", "

foo - bar

\n", "foo -- bar\n", "

foo – bar

\n", "foo --- bar\n", "

foo — bar

\n", }, TestParams{HTMLFlags: Smartypants | SmartypantsLatexDashes | SmartypantsDashes}) doTestsInlineParam(t, []string{ "foo - bar\n", "

foo - bar

\n", "foo -- bar\n", "

foo -- bar

\n", "foo --- bar\n", "

foo --- bar

\n", }, TestParams{HTMLFlags: Smartypants | SmartypantsLatexDashes}) } func TestSkipLinks(t *testing.T) { t.Parallel() doTestsInlineParam(t, []string{ "[foo](gopher://foo.bar)", "

foo

\n", "[foo](mailto://bar/)\n", "

foo

\n", }, TestParams{ HTMLFlags: SkipLinks, }) } func TestSkipImages(t *testing.T) { t.Parallel() doTestsInlineParam(t, []string{ "![foo](/bar/)\n", "

\n", }, TestParams{ HTMLFlags: SkipImages, }) } func TestUseXHTML(t *testing.T) { t.Parallel() doTestsParam(t, []string{ "---", "

\n", }, TestParams{}) doTestsParam(t, []string{ "---", "

\n", }, TestParams{HTMLFlags: UseXHTML}) } func TestSkipHTML(t *testing.T) { t.Parallel() doTestsParam(t, []string{ "

\n\ntext\n\n", "

text

\n\n

the form

\n", "text inline html more text", "

text inline html more text

\n", }, TestParams{HTMLFlags: SkipHTML}) } func BenchmarkSmartDoubleQuotes(b *testing.B) { params := TestParams{HTMLFlags: Smartypants} params.extensions |= Autolink | Strikethrough params.HTMLFlags |= UseXHTML for i := 0; i < b.N; i++ { runMarkdown("this should be normal \"quoted\" text.\n", params) } } func TestIgnoreUnderscore(t *testing.T) { t.Parallel() var tests = []string{ "simple _inline_ test\n", "

simple _inline_ test

\n", "_at the_ beginning\n", "

_at the_ beginning

\n", "at the _end_\n", "

at the _end_

\n", "_try two_ in _one line_\n", "

_try two_ in _one line_

\n", "over _two\nlines_ test\n", "

over _two\nlines_ test

\n", "odd _number of_ markers_ here\n", "

odd _number of_ markers_ here

\n", "odd _number\nof_ markers_ here\n", "

odd _number\nof_ markers_ here

\n", "mix of *markers_\n", "

mix of *markers_

\n", } doTestsInlineParam(t, tests, TestParams{extensions: IgnoreUnderscore}) }