` within a HTML block started by `
` tags? Can a list be partially "loose" and partially + // "tight"? What should we do with a list like this? + // + // ``` markdown + // 1. one + // + // 2. two + // 3. three + // ``` + // + // Or this? + // + // ``` markdown + // 1. one + // - a + // + // - b + // 2. two + // ``` + // + // (There are some relevant comments by John Gruber + // [here](http://article.gmane.org/gmane.text.markdown.general/2554).) + // + // 5. Can list markers be indented? Can ordered list markers be right-aligned? + // + // ``` markdown + // 8. item 1 + // 9. item 2 + // 10. item 2a + // ``` + // + // 6. Is this one list with a thematic break in its second item, + // or two lists separated by a thematic break? + // + // ``` markdown + // * a + // * * * * * + // * b + // ``` + // + // 7. When list markers change from numbers to bullets, do we have + // two lists or one? (The Markdown syntax description suggests two, + // but the perl scripts and many other implementations produce one.) + // + // ``` markdown + // 1. fee + // 2. fie + // - foe + // - fum + // ``` + // + // 8. What are the precedence rules for the markers of inline structure? + // For example, is the following a valid link, or does the code span + // take precedence ? + // + // ``` markdown + // [a backtick (`)](/url) and [another backtick (`)](/url). + // ``` + // + // 9. What are the precedence rules for markers of emphasis and strong + // emphasis? For example, how should the following be parsed? + // + // ``` markdown + // *foo *bar* baz* + // ``` + // + // 10. What are the precedence rules between block-level and inline-level + // structure? For example, how should the following be parsed? + // + // ``` markdown + // - `a long code span can contain a hyphen like this + // - and it can screw things up` + // ``` + // + // 11. Can list items include section headings? (`Markdown.pl` does not + // allow this, but does allow blockquotes to include headings.) + // + // ``` markdown + // - # Heading + // ``` + // + // 12. Can list items be empty? + // + // ``` markdown + // * a + // * + // * b + // ``` + // + // 13. Can link references be defined inside block quotes or list items? + // + // ``` markdown + // > Blockquote [foo]. + // > + // > [foo]: /url + // ``` + // + // 14. If there are multiple definitions for the same reference, which takes + // precedence? + // + // ``` markdown + // [foo]: /url1 + // [foo]: /url2 + // + // [foo][] + // ``` + // + // In the absence of a spec, early implementers consulted `Markdown.pl` + // to resolve these ambiguities. But `Markdown.pl` was quite buggy, and + // gave manifestly bad results in many cases, so it was not a + // satisfactory replacement for a spec. + // + // Because there is no unambiguous spec, implementations have diverged + // considerably. As a result, users are often surprised to find that + // a document that renders one way on one system (say, a GitHub wiki) + // renders differently on another (say, converting to docbook using + // pandoc). To make matters worse, because nothing in Markdown counts + // as a "syntax error," the divergence often isn't discovered right away. + // + // ## About this document + // + // This document attempts to specify Markdown syntax unambiguously. + // It contains many examples with side-by-side Markdown and + // HTML. These are intended to double as conformance tests. An + // accompanying script `spec_tests.py` can be used to run the tests + // against any Markdown program: + // + // python test/spec_tests.py --spec spec.txt --program PROGRAM + // + // Since this document describes how Markdown is to be parsed into + // an abstract syntax tree, it would have made sense to use an abstract + // representation of the syntax tree instead of HTML. But HTML is capable + // of representing the structural distinctions we need to make, and the + // choice of HTML for the tests makes it possible to run the tests against + // an implementation without writing an abstract syntax tree renderer. + // + // This document is generated from a text file, `spec.txt`, written + // in Markdown with a small extension for the side-by-side tests. + // The script `tools/makespec.py` can be used to convert `spec.txt` into + // HTML or CommonMark (which can then be converted into other formats). + // + // In the examples, the `→` character is used to represent tabs. + // + // # Preliminaries + // + // ## Characters and lines + // + // Any sequence of [characters] is a valid CommonMark + // document. + // + // A [character](@) is a Unicode code point. Although some + // code points (for example, combining accents) do not correspond to + // characters in an intuitive sense, all code points count as characters + // for purposes of this spec. + // + // This spec does not specify an encoding; it thinks of lines as composed + // of [characters] rather than bytes. A conforming parser may be limited + // to a certain encoding. + // + // A [line](@) is a sequence of zero or more [characters] + // other than newline (`U+000A`) or carriage return (`U+000D`), + // followed by a [line ending] or by the end of file. + // + // A [line ending](@) is a newline (`U+000A`), a carriage return + // (`U+000D`) not followed by a newline, or a carriage return and a + // following newline. + // + // A line containing no characters, or a line containing only spaces + // (`U+0020`) or tabs (`U+0009`), is called a [blank line](@). + // + // The following definitions of character classes will be used in this spec: + // + // A [whitespace character](@) is a space + // (`U+0020`), tab (`U+0009`), newline (`U+000A`), line tabulation (`U+000B`), + // form feed (`U+000C`), or carriage return (`U+000D`). + // + // [Whitespace](@) is a sequence of one or more [whitespace + // characters]. + // + // A [Unicode whitespace character](@) is + // any code point in the Unicode `Zs` general category, or a tab (`U+0009`), + // carriage return (`U+000D`), newline (`U+000A`), or form feed + // (`U+000C`). + // + // [Unicode whitespace](@) is a sequence of one + // or more [Unicode whitespace characters]. + // + // A [space](@) is `U+0020`. + // + // A [non-whitespace character](@) is any character + // that is not a [whitespace character]. + // + // An [ASCII punctuation character](@) + // is `!`, `"`, `#`, `$`, `%`, `&`, `'`, `(`, `)`, + // `*`, `+`, `,`, `-`, `.`, `/` (U+0021–2F), + // `:`, `;`, `<`, `=`, `>`, `?`, `@` (U+003A–0040), + // `[`, `\`, `]`, `^`, `_`, `` ` `` (U+005B–0060), + // `{`, `|`, `}`, or `~` (U+007B–007E). + // + // A [punctuation character](@) is an [ASCII + // punctuation character] or anything in + // the general Unicode categories `Pc`, `Pd`, `Pe`, `Pf`, `Pi`, `Po`, or `Ps`. + // + // ## Tabs + // + // Tabs in lines are not expanded to [spaces]. However, + // in contexts where whitespace helps to define block structure, + // tabs behave as if they were replaced by spaces with a tab stop + // of 4 characters. + // + // Thus, for example, a tab can be used instead of four spaces + // in an indented code block. (Note, however, that internal + // tabs are passed through as literal tabs, not expanded to + // spaces.) + [Test] + public void PreliminariesTabs_Example001() + { + // Example 1 + // Section: Preliminaries / Tabs + // + // The following Markdown: + // →foo→baz→→bim + // + // Should be rendered as: + //
foo→baz→→bim
+ // foo\tbaz\t\tbim\nfoo→baz→→bim
+ // foo\tbaz\t\tbim\na→a
+ // ὐ→a
+ // a\ta\nὐ\ta\nfoo
+ //bar
+ //foo
\nbar
\nfoo
+ // bar
+ // foo
\n bar\n+ //+ + Console.WriteLine("Example 6\nSection Preliminaries / Tabs\n"); + TestRoundtrip.TestSpec(">\t\tfoo", "+ //foo + //
\n", ""); + } + + [Test] + public void PreliminariesTabs_Example007() + { + // Example 7 + // Section: Preliminaries / Tabs + // + // The following Markdown: + // -→→foo + // + // Should be rendered as: + //\nfoo\n
foo
+ // foo\nfoo
+ // bar
+ // foo\nbar\n+++
+ + Console.WriteLine("Example 14\nSection Leaf blocks / Thematic breaks\n"); + TestRoundtrip.TestSpec("+++", "+++
", ""); + } + + [Test] + public void LeafBlocksThematicBreaks_Example015() + { + // Example 15 + // Section: Leaf blocks / Thematic breaks + // + // The following Markdown: + // === + // + // Should be rendered as: + //===
+ + Console.WriteLine("Example 15\nSection Leaf blocks / Thematic breaks\n"); + TestRoundtrip.TestSpec("===", "===
", ""); + } + + // Not enough characters: + [Test] + public void LeafBlocksThematicBreaks_Example016() + { + // Example 16 + // Section: Leaf blocks / Thematic breaks + // + // The following Markdown: + // -- + // ** + // __ + // + // Should be rendered as: + //-- + // ** + // __
+ + Console.WriteLine("Example 16\nSection Leaf blocks / Thematic breaks\n"); + TestRoundtrip.TestSpec("--\n**\n__", "--\n**\n__
", ""); + } + + // One to three spaces indent are allowed: + [Test] + public void LeafBlocksThematicBreaks_Example017() + { + // Example 17 + // Section: Leaf blocks / Thematic breaks + // + // The following Markdown: + // *** + // *** + // *** + // + // Should be rendered as: + //***
+ // ***\nFoo + // ***
+ + Console.WriteLine("Example 19\nSection Leaf blocks / Thematic breaks\n"); + TestRoundtrip.TestSpec("Foo\n ***", "Foo\n***
", ""); + } + + // More than three characters may be used: + [Test] + public void LeafBlocksThematicBreaks_Example020() + { + // Example 20 + // Section: Leaf blocks / Thematic breaks + // + // The following Markdown: + // _____________________________________ + // + // Should be rendered as: + //_ _ _ _ a
+ //a------
+ //---a---
+ + Console.WriteLine("Example 25\nSection Leaf blocks / Thematic breaks\n"); + TestRoundtrip.TestSpec("_ _ _ _ a\n\na------\n\n---a---", "_ _ _ _ a
\na------
\n---a---
", ""); + } + + // It is required that all of the [non-whitespace characters] be the same. + // So, this is not a thematic break: + [Test] + public void LeafBlocksThematicBreaks_Example026() + { + // Example 26 + // Section: Leaf blocks / Thematic breaks + // + // The following Markdown: + // *-* + // + // Should be rendered as: + //-
+ + Console.WriteLine("Example 26\nSection Leaf blocks / Thematic breaks\n"); + TestRoundtrip.TestSpec(" *-*", "-
", ""); + } + + // Thematic breaks do not need blank lines before or after: + [Test] + public void LeafBlocksThematicBreaks_Example027() + { + // Example 27 + // Section: Leaf blocks / Thematic breaks + // + // The following Markdown: + // - foo + // *** + // - bar + // + // Should be rendered as: + //Foo
+ //bar
+ + Console.WriteLine("Example 28\nSection Leaf blocks / Thematic breaks\n"); + TestRoundtrip.TestSpec("Foo\n***\nbar", "Foo
\nbar
", ""); + } + + // If a line of dashes that meets the above conditions for being a + // thematic break could also be interpreted as the underline of a [setext + // heading], the interpretation as a + // [setext heading] takes precedence. Thus, for example, + // this is a setext heading, not a paragraph followed by a thematic break: + [Test] + public void LeafBlocksThematicBreaks_Example029() + { + // Example 29 + // Section: Leaf blocks / Thematic breaks + // + // The following Markdown: + // Foo + // --- + // bar + // + // Should be rendered as: + //bar
+ + Console.WriteLine("Example 29\nSection Leaf blocks / Thematic breaks\n"); + TestRoundtrip.TestSpec("Foo\n---\nbar", "bar
", ""); + } + + // When both a thematic break and a list item are possible + // interpretations of a line, the thematic break takes precedence: + [Test] + public void LeafBlocksThematicBreaks_Example030() + { + // Example 30 + // Section: Leaf blocks / Thematic breaks + // + // The following Markdown: + // * Foo + // * * * + // * Bar + // + // Should be rendered as: + //####### foo
+ + Console.WriteLine("Example 33\nSection Leaf blocks / ATX headings\n"); + TestRoundtrip.TestSpec("####### foo", "####### foo
", ""); + } + + // At least one space is required between the `#` characters and the + // heading's contents, unless the heading is empty. Note that many + // implementations currently do not require the space. However, the + // space was required by the + // [original ATX implementation](http://www.aaronsw.com/2002/atx/atx.py), + // and it helps prevent things like the following from being parsed as + // headings: + [Test] + public void LeafBlocksATXHeadings_Example034() + { + // Example 34 + // Section: Leaf blocks / ATX headings + // + // The following Markdown: + // #5 bolt + // + // #hashtag + // + // Should be rendered as: + //#5 bolt
+ //#hashtag
+ + Console.WriteLine("Example 34\nSection Leaf blocks / ATX headings\n"); + TestRoundtrip.TestSpec("#5 bolt\n\n#hashtag", "#5 bolt
\n#hashtag
", ""); + } + + // This is not a heading, because the first `#` is escaped: + [Test] + public void LeafBlocksATXHeadings_Example035() + { + // Example 35 + // Section: Leaf blocks / ATX headings + // + // The following Markdown: + // \## foo + // + // Should be rendered as: + //## foo
+ + Console.WriteLine("Example 35\nSection Leaf blocks / ATX headings\n"); + TestRoundtrip.TestSpec("\\## foo", "## foo
", ""); + } + + // Contents are parsed as inlines: + [Test] + public void LeafBlocksATXHeadings_Example036() + { + // Example 36 + // Section: Leaf blocks / ATX headings + // + // The following Markdown: + // # foo *bar* \*baz\* + // + // Should be rendered as: + //# foo
+ // # foo\nfoo + // # bar
+ + Console.WriteLine("Example 40\nSection Leaf blocks / ATX headings\n"); + TestRoundtrip.TestSpec("foo\n # bar", "foo\n# bar
", ""); + } + + // A closing sequence of `#` characters is optional: + [Test] + public void LeafBlocksATXHeadings_Example041() + { + // Example 41 + // Section: Leaf blocks / ATX headings + // + // The following Markdown: + // ## foo ## + // ### bar ### + // + // Should be rendered as: + //Foo bar
+ //Bar foo
+ + Console.WriteLine("Example 48\nSection Leaf blocks / ATX headings\n"); + TestRoundtrip.TestSpec("Foo bar\n# baz\nBar foo", "Foo bar
\nBar foo
", ""); + } + + // ATX headings can be empty: + [Test] + public void LeafBlocksATXHeadings_Example049() + { + // Example 49 + // Section: Leaf blocks / ATX headings + // + // The following Markdown: + // ## + // # + // ### ### + // + // Should be rendered as: + // + // + // + + Console.WriteLine("Example 49\nSection Leaf blocks / ATX headings\n"); + TestRoundtrip.TestSpec("## \n#\n### ###", "\n\n", ""); + } + } + + [TestFixture] + public class TestLeafBlocksSetextHeadings + { + // ## Setext headings + // + // A [setext heading](@) consists of one or more + // lines of text, each containing at least one [non-whitespace + // character], with no more than 3 spaces indentation, followed by + // a [setext heading underline]. The lines of text must be such + // that, were they not followed by the setext heading underline, + // they would be interpreted as a paragraph: they cannot be + // interpretable as a [code fence], [ATX heading][ATX headings], + // [block quote][block quotes], [thematic break][thematic breaks], + // [list item][list items], or [HTML block][HTML blocks]. + // + // A [setext heading underline](@) is a sequence of + // `=` characters or a sequence of `-` characters, with no more than 3 + // spaces indentation and any number of trailing spaces. If a line + // containing a single `-` can be interpreted as an + // empty [list items], it should be interpreted this way + // and not as a [setext heading underline]. + // + // The heading is a level 1 heading if `=` characters are used in + // the [setext heading underline], and a level 2 heading if `-` + // characters are used. The contents of the heading are the result + // of parsing the preceding lines of text as CommonMark inline + // content. + // + // In general, a setext heading need not be preceded or followed by a + // blank line. However, it cannot interrupt a paragraph, so when a + // setext heading comes after a paragraph, a blank line is needed between + // them. + // + // Simple examples: + [Test] + public void LeafBlocksSetextHeadings_Example050() + { + // Example 50 + // Section: Leaf blocks / Setext headings + // + // The following Markdown: + // Foo *bar* + // ========= + // + // Foo *bar* + // --------- + // + // Should be rendered as: + //Foo
+ // ---
+ //
+ // Foo
+ // Foo\n---\n\nFoo\nFoo + // ---
+ + Console.WriteLine("Example 57\nSection Leaf blocks / Setext headings\n"); + TestRoundtrip.TestSpec("Foo\n ---", "Foo\n---
", ""); + } + + // The setext heading underline cannot contain internal spaces: + [Test] + public void LeafBlocksSetextHeadings_Example058() + { + // Example 58 + // Section: Leaf blocks / Setext headings + // + // The following Markdown: + // Foo + // = = + // + // Foo + // --- - + // + // Should be rendered as: + //Foo + // = =
+ //Foo
+ //Foo\n= =
\nFoo
\n`
+ //of dashes"/>
+ + Console.WriteLine("Example 61\nSection Leaf blocks / Setext headings\n"); + TestRoundtrip.TestSpec("`Foo\n----\n`\n\n", "`
\nof dashes"/>
", ""); + } + + // The setext heading underline cannot be a [lazy continuation + // line] in a list item or block quote: + [Test] + public void LeafBlocksSetextHeadings_Example062() + { + // Example 62 + // Section: Leaf blocks / Setext headings + // + // The following Markdown: + // > Foo + // --- + // + // Should be rendered as: + //+ //+ //Foo
+ //
\n\nFoo
\n
+ //+ + Console.WriteLine("Example 63\nSection Leaf blocks / Setext headings\n"); + TestRoundtrip.TestSpec("> foo\nbar\n===", "foo + // bar + // ===
+ //
\n", ""); + } + + [Test] + public void LeafBlocksSetextHeadings_Example064() + { + // Example 64 + // Section: Leaf blocks / Setext headings + // + // The following Markdown: + // - Foo + // --- + // + // Should be rendered as: + //foo\nbar\n===
\n
Baz
+ + Console.WriteLine("Example 66\nSection Leaf blocks / Setext headings\n"); + TestRoundtrip.TestSpec("---\nFoo\n---\nBar\n---\nBaz", "Baz
", ""); + } + + // Setext headings cannot be empty: + [Test] + public void LeafBlocksSetextHeadings_Example067() + { + // Example 67 + // Section: Leaf blocks / Setext headings + // + // The following Markdown: + // + // ==== + // + // Should be rendered as: + //====
+ + Console.WriteLine("Example 67\nSection Leaf blocks / Setext headings\n"); + TestRoundtrip.TestSpec("\n====", "====
", ""); + } + + // Setext heading text lines must not be interpretable as block + // constructs other than paragraphs. So, the line of dashes + // in these examples gets interpreted as a thematic break: + [Test] + public void LeafBlocksSetextHeadings_Example068() + { + // Example 68 + // Section: Leaf blocks / Setext headings + // + // The following Markdown: + // --- + // --- + // + // Should be rendered as: + //foo
+ // foo\n+ //+ //foo
+ //
\n\nfoo
\n
Foo
+ //baz
+ + Console.WriteLine("Example 73\nSection Leaf blocks / Setext headings\n"); + TestRoundtrip.TestSpec("Foo\n\nbar\n---\nbaz", "Foo
\nbaz
", ""); + } + + // Authors who want interpretation 2 can put blank lines around + // the thematic break, + [Test] + public void LeafBlocksSetextHeadings_Example074() + { + // Example 74 + // Section: Leaf blocks / Setext headings + // + // The following Markdown: + // Foo + // bar + // + // --- + // + // baz + // + // Should be rendered as: + //Foo + // bar
+ //baz
+ + Console.WriteLine("Example 74\nSection Leaf blocks / Setext headings\n"); + TestRoundtrip.TestSpec("Foo\nbar\n\n---\n\nbaz", "Foo\nbar
\nbaz
", ""); + } + + // or use a thematic break that cannot count as a [setext heading + // underline], such as + [Test] + public void LeafBlocksSetextHeadings_Example075() + { + // Example 75 + // Section: Leaf blocks / Setext headings + // + // The following Markdown: + // Foo + // bar + // * * * + // baz + // + // Should be rendered as: + //Foo + // bar
+ //baz
+ + Console.WriteLine("Example 75\nSection Leaf blocks / Setext headings\n"); + TestRoundtrip.TestSpec("Foo\nbar\n* * *\nbaz", "Foo\nbar
\nbaz
", ""); + } + + // Authors who want interpretation 3 can use backslash escapes: + [Test] + public void LeafBlocksSetextHeadings_Example076() + { + // Example 76 + // Section: Leaf blocks / Setext headings + // + // The following Markdown: + // Foo + // bar + // \--- + // baz + // + // Should be rendered as: + //Foo + // bar + // --- + // baz
+ + Console.WriteLine("Example 76\nSection Leaf blocks / Setext headings\n"); + TestRoundtrip.TestSpec("Foo\nbar\n\\---\nbaz", "Foo\nbar\n---\nbaz
", ""); + } + } + + [TestFixture] + public class TestLeafBlocksIndentedCodeBlocks + { + // ## Indented code blocks + // + // An [indented code block](@) is composed of one or more + // [indented chunks] separated by blank lines. + // An [indented chunk](@) is a sequence of non-blank lines, + // each indented four or more spaces. The contents of the code block are + // the literal contents of the lines, including trailing + // [line endings], minus four spaces of indentation. + // An indented code block has no [info string]. + // + // An indented code block cannot interrupt a paragraph, so there must be + // a blank line between a paragraph and a following indented code block. + // (A blank line is not needed, however, between a code block and a following + // paragraph.) + [Test] + public void LeafBlocksIndentedCodeBlocks_Example077() + { + // Example 77 + // Section: Leaf blocks / Indented code blocks + // + // The following Markdown: + // a simple + // indented code block + // + // Should be rendered as: + //a simple
+ // indented code block
+ // a simple\n indented code block\nfoo
+ //bar
+ //foo
\nbar
\nfoo
+ //foo
\n<a/>
+ // *hi*
+ //
+ // - one
+ // <a/>\n*hi*\n\n- one\nchunk1
+ //
+ // chunk2
+ //
+ //
+ //
+ // chunk3
+ // chunk1\n\nchunk2\n\n\n\nchunk3\nchunk1
+ //
+ // chunk2
+ // chunk1\n \n chunk2\nFoo + // bar
+ + Console.WriteLine("Example 83\nSection Leaf blocks / Indented code blocks\n"); + TestRoundtrip.TestSpec("Foo\n bar\n", "Foo\nbar
", ""); + } + + // However, any non-blank line with fewer than four leading spaces ends + // the code block immediately. So a paragraph may occur immediately + // after indented code: + [Test] + public void LeafBlocksIndentedCodeBlocks_Example084() + { + // Example 84 + // Section: Leaf blocks / Indented code blocks + // + // The following Markdown: + // foo + // bar + // + // Should be rendered as: + //foo
+ // bar
+ + Console.WriteLine("Example 84\nSection Leaf blocks / Indented code blocks\n"); + TestRoundtrip.TestSpec(" foo\nbar", "foo\nbar
", ""); + } + + // And indented code can occur immediately before and after other kinds of + // blocks: + [Test] + public void LeafBlocksIndentedCodeBlocks_Example085() + { + // Example 85 + // Section: Leaf blocks / Indented code blocks + // + // The following Markdown: + // # Heading + // foo + // Heading + // ------ + // foo + // ---- + // + // Should be rendered as: + //foo
+ // foo
+ // foo\nfoo\n foo
+ // bar
+ // foo\nbar\nfoo
+ // foo\nfoo
+ // foo \n<
+ // >
+ // <\n >\n<
+ // >
+ // <\n >\nfoo
foo
aaa
+ // ~~~
+ // aaa\n~~~\naaa
+ // ```
+ // aaa\n```\naaa
+ // ```
+ // aaa\n```\naaa
+ // ~~~
+ // aaa\n~~~\n
+ // ```
+ // aaa
+ // \n```\naaa\n+ //+ //+ //aaa + //
bbb
+ + Console.WriteLine("Example 98\nSection Leaf blocks / Fenced code blocks\n"); + TestRoundtrip.TestSpec("> ```\n> aaa\n\nbbb", "\n\n\naaa\n
bbb
", ""); + } + + // A code block can have all empty lines as its content: + [Test] + public void LeafBlocksFencedCodeBlocks_Example099() + { + // Example 99 + // Section: Leaf blocks / Fenced code blocks + // + // The following Markdown: + // ``` + // + // + // ``` + // + // Should be rendered as: + //
+ //
+ // \n \naaa
+ // aaa
+ // aaa\naaa\naaa
+ // aaa
+ // aaa
+ // aaa\naaa\naaa\naaa
+ // aaa
+ // aaa
+ // aaa\n aaa\naaa\n```
+ // aaa
+ // ```
+ // ```\naaa\n```\naaa
+ // aaa\naaa
+ // aaa\naaa
+ // ```
+ // aaa\n ```\n
+ // aaa
\naaa
aaa
+ // ~~~ ~~
+ // aaa\n~~~ ~~\nfoo
+ //bar
+ // baz
+ + Console.WriteLine("Example 110\nSection Leaf blocks / Fenced code blocks\n"); + TestRoundtrip.TestSpec("foo\n```\nbar\n```\nbaz", "foo
\nbar\nbaz
", ""); + } + + // Other blocks can also occur before and after fenced code blocks + // without an intervening blank line: + [Test] + public void LeafBlocksFencedCodeBlocks_Example111() + { + // Example 111 + // Section: Leaf blocks / Fenced code blocks + // + // The following Markdown: + // foo + // --- + // ~~~ + // bar + // ~~~ + // # baz + // + // Should be rendered as: + //bar
+ // bar\ndef foo(x)
+ // return 3
+ // end
+ // def foo(x)\n return 3\nend\ndef foo(x)
+ // return 3
+ // end
+ // def foo(x)\n return 3\nend\naa
+ // foo
aa\nfoo
foo
+ // foo\n``` aaa
+ // ``` aaa\n` within a HTML block started by `
![\"moon\"](\"moon.jpg\")
![\"foo](\"train.jpg\" "\\"train")
![\"foo](\"/path/to/train.jpg\" "\\"title\\"")