// // 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" "strings" "testing" ) func runMarkdownInline(input string, opts Options, htmlFlags int, params HtmlRendererParameters) string { opts.Extensions |= EXTENSION_AUTOLINK opts.Extensions |= EXTENSION_STRIKETHROUGH htmlFlags |= HTML_USE_XHTML renderer := HtmlRendererWithParameters(htmlFlags, "", "", params) return string(MarkdownOptions([]byte(input), renderer, opts)) } func doTestsInline(t *testing.T, tests []string) { doTestsInlineParam(t, tests, Options{}, 0, HtmlRendererParameters{}) } func doLinkTestsInline(t *testing.T, tests []string) { doTestsInline(t, tests) prefix := "http://localhost" params := HtmlRendererParameters{AbsolutePrefix: prefix} transformTests := transformLinks(tests, prefix) doTestsInlineParam(t, transformTests, Options{}, 0, params) doTestsInlineParam(t, transformTests, Options{}, commonHtmlFlags, params) } func doSafeTestsInline(t *testing.T, tests []string) { doTestsInlineParam(t, tests, Options{}, HTML_SAFELINK, HtmlRendererParameters{}) // All the links in this test should not have the prefix appended, so // just rerun it with different parameters and the same expectations. prefix := "http://localhost" params := HtmlRendererParameters{AbsolutePrefix: prefix} transformTests := transformLinks(tests, prefix) doTestsInlineParam(t, transformTests, Options{}, HTML_SAFELINK, params) } func doTestsInlineParam(t *testing.T, tests []string, opts Options, htmlFlags int, params HtmlRendererParameters) { // catch and report panics var candidate string defer func() { if err := recover(); err != nil { t.Errorf("\npanic while processing [%#v]: %s\n", candidate, err) } }() for i := 0; i+1 < len(tests); i += 2 { input := tests[i] candidate = input expected := tests[i+1] actual := runMarkdownInline(candidate, opts, htmlFlags, params) if actual != expected { t.Errorf("\nInput [%#v]\nExpected[%#v]\nActual [%#v]", candidate, expected, actual) } // now test every substring to stress test bounds checking if !testing.Short() { for start := 0; start < len(input); start++ { for end := start + 1; end <= len(input); end++ { candidate = input[start:end] _ = runMarkdownInline(candidate, opts, htmlFlags, params) } } } } } func transformLinks(tests []string, prefix string) []string { newTests := make([]string, len(tests)) anchorRe := regexp.MustCompile(`nothing inline

simple inline test

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", "some para_graph with _emphasised_ text.\n", "

some para_graph with emphasised text.

\n", "some paragraph with _emphasised_ te_xt.\n", "

some paragraph with emphasised te_xt.

\n", "some paragraph with t_wo bi_ts of _emphasised_ text.\n", "

some paragraph with two bits of emphasised text.

\n", "un*frigging*believable\n", "

unfriggingbelievable

\n", } doTestsInline(t, tests) } func TestNoIntraEmphasis(t *testing.T) { tests := []string{ "some para_graph with _emphasised_ text.\n", "

some para_graph with emphasised text.

\n", "un*frigging*believable\n", "

un*frigging*believable

\n", } doTestsInlineParam(t, tests, Options{ Extensions: EXTENSION_NO_INTRA_EMPHASIS}, 0, HtmlRendererParameters{}) } func TestReferenceOverride(t *testing.T) { 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, Options{ ReferenceOverride: func(reference string) (rv *Reference, overridden bool) { switch reference { case "ref1": // just an overriden 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 }}, 0, HtmlRendererParameters{}) } func TestStrong(t *testing.T) { 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) { 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) { 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) { 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) { 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) { 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, Options{ Extensions: EXTENSION_BACKSLASH_LINE_BREAK}, 0, HtmlRendererParameters{}) } func TestInlineLink(t *testing.T) { var tests = []string{ "[foo](/bar/)\n", "