def test_backslash_escapes_308():
"""
Test case 308: Any ASCII punctuation character may be backslash-escaped:
"""
# Arrange
tokenizer = TokenizedMarkdown()
transformer = TransformToGfm()
source_markdown = """\\!\\\"\\#\\$\\%\\&\\'\\(\\)\\*\\+\\,\\-\\.\\/\\:\\;\\<\\=\\>\\?\\@\\[\\\\\\]\\^\\_\\`\\{\\|\\}\\~"""
expected_tokens = [
"[para(1,1):]",
"[text:\\\b!\\\b\a\"\a"\a\\\b#\\\b$\\\b%\\\b\a&\a&\a\\\b'\\\b(\\\b)\\\b*\\\b+\\\b,\\\b-\\\b.\\\b/\\\b:\\\b;\\\b\a<\a<\a\\\b=\\\b\a>\a>\a\\\b?\\\b@\\\b[\\\b\\\\\b]\\\b^\\\b_\\\b`\\\b{\\\b|\\\b}\\\b~:]",
"[end-para]",
]
expected_gfm = """<p>!"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~</p>"""
# Act
actual_tokens = tokenizer.transform(source_markdown)
actual_gfm = transformer.transform(actual_tokens)
# Assert
assert_if_lists_different(expected_tokens, actual_tokens)
assert_if_strings_different(expected_gfm, actual_gfm)
assert_token_consistency(source_markdown, actual_tokens)
def test_autolinks_614():
"""
Test case 614: Backslash-escapes do not work inside email autolinks:
"""
# Arrange
tokenizer = TokenizedMarkdown()
transformer = TransformToGfm()
source_markdown = """<foo\\[email protected]>"""
expected_tokens = [
"[para(1,1):]",
"[text:\a<\a<\afoo\\\[email protected]\a>\a>\a:]",
"[end-para]",
]
expected_gfm = """<p><[email protected]></p>"""
# Act
actual_tokens = tokenizer.transform(source_markdown)
actual_gfm = transformer.transform(actual_tokens)
# Assert
assert_if_lists_different(expected_tokens, actual_tokens)
assert_if_strings_different(expected_gfm, actual_gfm)
assert_token_consistency(source_markdown, actual_tokens)
def test_autolinks_618():
"""
Test case 618: (part 4) These are not autolinks:
"""
# Arrange
tokenizer = TokenizedMarkdown()
transformer = TransformToGfm()
source_markdown = """<foo.bar.baz>"""
expected_tokens = [
"[para(1,1):]",
"[text:\a<\a<\afoo.bar.baz\a>\a>\a:]",
"[end-para]",
]
expected_gfm = """<p><foo.bar.baz></p>"""
# Act
actual_tokens = tokenizer.transform(source_markdown)
actual_gfm = transformer.transform(actual_tokens)
# Assert
assert_if_lists_different(expected_tokens, actual_tokens)
assert_if_strings_different(expected_gfm, actual_gfm)
assert_token_consistency(source_markdown, actual_tokens)
def test_autolinks_610():
"""
Test case 610: Spaces are not allowed in autolinks:
"""
# Arrange
tokenizer = TokenizedMarkdown()
transformer = TransformToGfm()
source_markdown = """<http://foo.bar/baz bim>"""
expected_tokens = [
"[para(1,1):]",
"[text:\a<\a<\ahttp://foo.bar/baz bim\a>\a>\a:]",
"[end-para]",
]
expected_gfm = """<p><http://foo.bar/baz bim></p>"""
# Act
actual_tokens = tokenizer.transform(source_markdown)
actual_gfm = transformer.transform(actual_tokens)
# Assert
assert_if_lists_different(expected_tokens, actual_tokens)
assert_if_strings_different(expected_gfm, actual_gfm)
assert_token_consistency(source_markdown, actual_tokens)
def test_autolinks_611b():
"""
Test case 611b: Backslash-escapes do not work inside autolinks:
"""
# Arrange
tokenizer = TokenizedMarkdown()
transformer = TransformToGfm()
source_markdown = """<http://abcdefjhijklmnopqrstuvwxyz!"#$%&'()*+,-./0123456789:;=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`{}|~ABC>"""
expected_tokens = [
"[para(1,1):]",
"[uri-autolink:http://abcdefjhijklmnopqrstuvwxyz!\"#$%&'()*+,-./0123456789:;=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`{}|~ABC]",
"[end-para]",
]
expected_gfm = """<p><a href="http://abcdefjhijklmnopqrstuvwxyz!%22#$%25&'()*+,-./0123456789:;=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ%5B%5C%5D%5E_%60%7B%7D%7C~ABC">http://abcdefjhijklmnopqrstuvwxyz!"#$%&'()*+,-./0123456789:;=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`{}|~ABC</a></p>"""
# Act
actual_tokens = tokenizer.transform(source_markdown)
actual_gfm = transformer.transform(actual_tokens)
# Assert
assert_if_lists_different(expected_tokens, actual_tokens)
assert_if_strings_different(expected_gfm, actual_gfm)
assert_token_consistency(source_markdown, actual_tokens)
def test_indented_code_blocks_083():
"""
Test case 083: An indented code block cannot interrupt a paragraph. (This allows hanging indents and the like.)
"""
# Arrange
tokenizer = TokenizedMarkdown()
transformer = TransformToGfm()
source_markdown = """Foo
bar"""
expected_tokens = [
"[para(1,1):\n ]", "[text:Foo\nbar::\n]", "[end-para]"
]
expected_gfm = """<p>Foo
bar</p>"""
# Act
actual_tokens = tokenizer.transform(source_markdown)
actual_gfm = transformer.transform(actual_tokens)
# Assert
assert_if_lists_different(expected_tokens, actual_tokens)
assert_if_strings_different(expected_gfm, actual_gfm)
assert_token_consistency(source_markdown, actual_tokens)
def test_thematic_breaks_031():
"""
Test case 031: If you want a thematic break in a list item, use a different bullet:
"""
# Arrange
tokenizer = TokenizedMarkdown()
transformer = TransformToGfm()
source_markdown = """
- Foo
- * * *"""
expected_tokens = [
"[BLANK(1,1):]",
"[ulist(2,1):-::2:]",
"[para(2,3):]",
"[text:Foo:]",
"[end-para]",
"[li(3,1):2:]",
"[tbreak(3,3):*::* * *]",
"[end-ulist]",
]
expected_gfm = """<ul>
<li>Foo</li>
<li>
<hr />
</li>
</ul>"""
# Act
actual_tokens = tokenizer.transform(source_markdown)
actual_gfm = transformer.transform(actual_tokens)
# Assert
assert_if_lists_different(expected_tokens, actual_tokens)
assert_if_strings_different(expected_gfm, actual_gfm)
assert_token_consistency(source_markdown, actual_tokens)
def test_character_references_325():
"""
Test case 325: Although HTML5 does accept some entity references without a trailing semicolon (such as ©), these are not recognized here, because it makes the grammar too ambiguous:
"""
# Arrange
tokenizer = TokenizedMarkdown()
transformer = TransformToGfm()
source_markdown = """©"""
expected_tokens = [
"[para(1,1):]",
"[text:\a&\a&\acopy:]",
"[end-para]",
]
expected_gfm = """<p>&copy</p>"""
# Act
actual_tokens = tokenizer.transform(source_markdown)
actual_gfm = transformer.transform(actual_tokens)
# Assert
assert_if_lists_different(expected_tokens, actual_tokens)
assert_if_strings_different(expected_gfm, actual_gfm)
assert_token_consistency(source_markdown, actual_tokens)
def test_character_references_326():
"""
Test case 326: Strings that are not on the list of HTML5 named entities are not recognized as entity references either:
"""
# Arrange
tokenizer = TokenizedMarkdown()
transformer = TransformToGfm()
source_markdown = """&MadeUpEntity;"""
expected_tokens = [
"[para(1,1):]",
"[text:\a&\a&\aMadeUpEntity;:]",
"[end-para]",
]
expected_gfm = """<p>&MadeUpEntity;</p>"""
# Act
actual_tokens = tokenizer.transform(source_markdown)
actual_gfm = transformer.transform(actual_tokens)
# Assert
assert_if_lists_different(expected_tokens, actual_tokens)
assert_if_strings_different(expected_gfm, actual_gfm)
assert_token_consistency(source_markdown, actual_tokens)
def test_backslash_escapes_309():
"""
Test case 309: Backslashes before other characters are treated as literal backslashes:
"""
# Arrange
tokenizer = TokenizedMarkdown()
transformer = TransformToGfm()
source_markdown = """\\→\\A\\a\\ \\3\\φ\\«"""
expected_tokens = [
"[para(1,1):]",
"[text:\\→\\A\\a\\ \\3\\φ\\«:]",
"[end-para]",
]
expected_gfm = """<p>\\→\\A\\a\\ \\3\\φ\\«</p>"""
# Act
actual_tokens = tokenizer.transform(source_markdown)
actual_gfm = transformer.transform(actual_tokens)
# Assert
assert_if_lists_different(expected_tokens, actual_tokens)
assert_if_strings_different(expected_gfm, actual_gfm)
assert_token_consistency(source_markdown, actual_tokens)
def test_character_references_324a():
"""
Test case 324a: Extension of 324
"""
# Arrange
tokenizer = TokenizedMarkdown()
transformer = TransformToGfm()
source_markdown = """&"""
expected_tokens = [
"[para(1,1):]",
"[text:\a&\a&\a:]",
"[end-para]",
]
expected_gfm = """<p>&</p>"""
# Act
actual_tokens = tokenizer.transform(source_markdown)
actual_gfm = transformer.transform(actual_tokens)
# Assert
assert_if_lists_different(expected_tokens, actual_tokens)
assert_if_strings_different(expected_gfm, actual_gfm)
assert_token_consistency(source_markdown, actual_tokens)
def test_backslash_escapes_317():
"""
Test case 317: (part 5) Backslash escapes do not work in code blocks, code spans, autolinks, or raw HTML:
"""
# Arrange
tokenizer = TokenizedMarkdown()
transformer = TransformToGfm()
source_markdown = """<a href="/bar\\/)">"""
expected_tokens = [
"[html-block(1,1)]",
'[text:<a href="/bar\\/)">:]',
"[end-html-block]",
]
expected_gfm = """<a href="/bar\\/)">"""
# Act
actual_tokens = tokenizer.transform(source_markdown)
actual_gfm = transformer.transform(actual_tokens)
# Assert
assert_if_lists_different(expected_tokens, actual_tokens)
assert_if_strings_different(expected_gfm, actual_gfm)
assert_token_consistency(source_markdown, actual_tokens)
def test_backslash_escapes_316():
"""
Test case 316: (part 4) Backslash escapes do not work in code blocks, code spans, autolinks, or raw HTML:
"""
# Arrange
tokenizer = TokenizedMarkdown()
transformer = TransformToGfm()
source_markdown = """<http://example.com?find=\\*>"""
expected_tokens = [
"[para(1,1):]",
"[uri-autolink:http://example.com?find=\\*]",
"[end-para]",
]
expected_gfm = """<p><a href="http://example.com?find=%5C*">http://example.com?find=\\*</a></p>"""
# Act
actual_tokens = tokenizer.transform(source_markdown)
actual_gfm = transformer.transform(actual_tokens)
# Assert
assert_if_lists_different(expected_tokens, actual_tokens)
assert_if_strings_different(expected_gfm, actual_gfm)
assert_token_consistency(source_markdown, actual_tokens)
def test_backslash_escapes_313():
"""
Test case 313: (part 1) Backslash escapes do not work in code blocks, code spans, autolinks, or raw HTML:
"""
# Arrange
tokenizer = TokenizedMarkdown()
transformer = TransformToGfm()
source_markdown = """`` \\[\\` ``"""
expected_tokens = [
"[para(1,1):]",
"[icode-span:\\[\\`:``: : ]",
"[end-para]",
]
expected_gfm = """<p><code>\\[\\`</code></p>"""
# Act
actual_tokens = tokenizer.transform(source_markdown)
actual_gfm = transformer.transform(actual_tokens)
# Assert
assert_if_lists_different(expected_tokens, actual_tokens)
assert_if_strings_different(expected_gfm, actual_gfm)
assert_token_consistency(source_markdown, actual_tokens)
def test_image_link_582():
"""
Test case 582: (part 3) Syntax for images is like the syntax for links, with one difference
"""
# Arrange
tokenizer = TokenizedMarkdown()
transformer = TransformToGfm()
source_markdown = """](/url2)"""
expected_tokens = [
"[para(1,1):]",
"[image:inline:/url2::foo bar::::foo bar]",
"[end-para]",
]
expected_gfm = """<p><img src="/url2" alt="foo bar" /></p>"""
# Act
actual_tokens = tokenizer.transform(source_markdown)
actual_gfm = transformer.transform(actual_tokens)
# Assert
assert_if_lists_different(expected_tokens, actual_tokens)
assert_if_strings_different(expected_gfm, actual_gfm)
assert_token_consistency(source_markdown, actual_tokens)
def test_character_references_327():
"""
Test case 327: (part 1) Entity and numeric character references are recognized in any context besides code spans or code blocks, including URLs, link titles, and fenced code block info strings:
"""
# Arrange
tokenizer = TokenizedMarkdown()
transformer = TransformToGfm()
source_markdown = '<a href="öö.html">'
expected_tokens = [
"[html-block(1,1)]",
'[text:<a href="öö.html">:]',
"[end-html-block]",
]
expected_gfm = """<a href="öö.html">"""
# Act
actual_tokens = tokenizer.transform(source_markdown)
actual_gfm = transformer.transform(actual_tokens)
# Assert
assert_if_lists_different(expected_tokens, actual_tokens)
assert_if_strings_different(expected_gfm, actual_gfm)
assert_token_consistency(source_markdown, actual_tokens)
def test_hard_line_breaks_664():
"""
Test case 664: (part 2) or HTML tags:
"""
# Arrange
tokenizer = TokenizedMarkdown()
transformer = TransformToGfm()
source_markdown = """<a href="foo\\
bar">"""
expected_tokens = [
"[para(1,1):\n]", '[raw-html:a href="foo\\\nbar"]', "[end-para]"
]
expected_gfm = """<p><a href="foo\\
bar"></p>"""
# Act
actual_tokens = tokenizer.transform(source_markdown)
actual_gfm = transformer.transform(actual_tokens)
# Assert
assert_if_lists_different(expected_tokens, actual_tokens)
assert_if_strings_different(expected_gfm, actual_gfm)
assert_token_consistency(source_markdown, actual_tokens)
def test_character_references_331():
"""
Test case 331: (part 1) Entity and numeric character references are treated as literal text in code spans and code blocks:
"""
# Arrange
tokenizer = TokenizedMarkdown()
transformer = TransformToGfm()
source_markdown = """`föö`"""
expected_tokens = [
"[para(1,1):]",
"[icode-span:f\a&\a&\aouml;\a&\a&\aouml;:`::]",
"[end-para]",
]
expected_gfm = """<p><code>f&ouml;&ouml;</code></p>"""
# Act
actual_tokens = tokenizer.transform(source_markdown)
actual_gfm = transformer.transform(actual_tokens)
# Assert
assert_if_lists_different(expected_tokens, actual_tokens)
assert_if_strings_different(expected_gfm, actual_gfm)
assert_token_consistency(source_markdown, actual_tokens)
def test_emphasis_441():
"""
Test case 441: (part 1) Indefinite levels of nesting are possible:
"""
# Arrange
tokenizer = TokenizedMarkdown()
transformer = TransformToGfm()
source_markdown = """**foo *bar **baz**
bim* bop**"""
expected_tokens = [
"[para(1,1):\n]",
"[emphasis:2:*]",
"[text:foo :]",
"[emphasis:1:*]",
"[text:bar :]",
"[emphasis:2:*]",
"[text:baz:]",
"[end-emphasis::2:*]",
"[text:\nbim::\n]",
"[end-emphasis::1:*]",
"[text: bop:]",
"[end-emphasis::2:*]",
"[end-para]",
]
expected_gfm = """<p><strong>foo <em>bar <strong>baz</strong>
bim</em> bop</strong></p>"""
# Act
actual_tokens = tokenizer.transform(source_markdown)
actual_gfm = transformer.transform(actual_tokens)
# Assert
assert_if_lists_different(expected_tokens, actual_tokens)
assert_if_strings_different(expected_gfm, actual_gfm)
assert_token_consistency(source_markdown, actual_tokens)
def test_character_references_322():
"""
Test case 322: Decimal numeric character references consist of &# + a string of 1–7 arabic digits + ;. A numeric character reference is parsed as the corresponding Unicode character. Invalid Unicode code points will be replaced by the REPLACEMENT CHARACTER (U+FFFD). For security reasons, the code point U+0000 will also be replaced by U+FFFD.
"""
# Arrange
tokenizer = TokenizedMarkdown()
transformer = TransformToGfm()
source_markdown = """# Ӓ Ϡ �"""
expected_tokens = [
"[para(1,1):]",
"[text:\a#\a#\a \aӒ\aӒ\a \aϠ\aϠ\a \a�\a�\a:]",
"[end-para]",
]
expected_gfm = """<p># Ӓ Ϡ �</p>"""
# Act
actual_tokens = tokenizer.transform(source_markdown)
actual_gfm = transformer.transform(actual_tokens)
# Assert
assert_if_lists_different(expected_tokens, actual_tokens)
assert_if_strings_different(expected_gfm, actual_gfm)
assert_token_consistency(source_markdown, actual_tokens)
def test_autolinks_609():
"""
Test case 609: (part 4) Note that many strings that count as absolute URIs for purposes of this spec are not valid URIs, because their schemes are not registered or because of other problems with their syntax:
"""
# Arrange
tokenizer = TokenizedMarkdown()
transformer = TransformToGfm()
source_markdown = """<localhost:5001/foo>"""
expected_tokens = [
"[para(1,1):]",
"[uri-autolink:localhost:5001/foo]",
"[end-para]",
]
expected_gfm = """<p><a href="localhost:5001/foo">localhost:5001/foo</a></p>"""
# Act
actual_tokens = tokenizer.transform(source_markdown)
actual_gfm = transformer.transform(actual_tokens)
# Assert
assert_if_lists_different(expected_tokens, actual_tokens)
assert_if_strings_different(expected_gfm, actual_gfm)
assert_token_consistency(source_markdown, actual_tokens)
def test_character_references_336():
"""
Test case 336: (part 4) Entity and numeric character references cannot be used in place of symbols indicating structure in CommonMark documents.
"""
# Arrange
tokenizer = TokenizedMarkdown()
transformer = TransformToGfm()
source_markdown = """	foo"""
expected_tokens = [
"[para(1,1):]",
"[text:\a	\a\t\afoo:]",
"[end-para]",
]
expected_gfm = """<p>\tfoo</p>"""
# Act
actual_tokens = tokenizer.transform(source_markdown)
actual_gfm = transformer.transform(actual_tokens)
# Assert
assert_if_lists_different(expected_tokens, actual_tokens)
assert_if_strings_different(expected_gfm, actual_gfm)
assert_token_consistency(source_markdown, actual_tokens)
def test_autolinks_611a():
"""
Test case 611a: Backslash-escapes do not work inside autolinks:
"""
# Arrange
tokenizer = TokenizedMarkdown()
transformer = TransformToGfm()
source_markdown = """<http://example.com/\u2122\u20AC>"""
expected_tokens = [
"[para(1,1):]",
"[uri-autolink:http://example.com/™€]",
"[end-para]",
]
expected_gfm = """<p><a href="http://example.com/%E2%84%A2%E2%82%AC">http://example.com/™€</a></p>"""
# Act
actual_tokens = tokenizer.transform(source_markdown)
actual_gfm = transformer.transform(actual_tokens)
# Assert
assert_if_lists_different(expected_tokens, actual_tokens)
assert_if_strings_different(expected_gfm, actual_gfm)
assert_token_consistency(source_markdown, actual_tokens)
def test_character_references_323():
"""
Test case 323: Hexadecimal numeric character references consist of &# + either X or x + a string of 1-6 hexadecimal digits + ;. They too are parsed as the corresponding Unicode character (this time specified with a hexadecimal numeral instead of decimal).
"""
# Arrange
tokenizer = TokenizedMarkdown()
transformer = TransformToGfm()
source_markdown = """" ആ ಫ"""
expected_tokens = [
"[para(1,1):]",
'[text:\a"\a\a"\a"\a\a \aആ\aആ\a \aಫ\aಫ\a:]',
"[end-para]",
]
expected_gfm = """<p>" ആ ಫ</p>"""
# Act
actual_tokens = tokenizer.transform(source_markdown)
actual_gfm = transformer.transform(actual_tokens)
# Assert
assert_if_lists_different(expected_tokens, actual_tokens)
assert_if_strings_different(expected_gfm, actual_gfm)
assert_token_consistency(source_markdown, actual_tokens)
def test_autolinks_613():
"""
Test case 613: (part 2) Examples of email autolinks:
"""
# Arrange
tokenizer = TokenizedMarkdown()
transformer = TransformToGfm()
source_markdown = """<*****@*****.**>"""
expected_tokens = [
"[para(1,1):]",
"[email-autolink:[email protected]]",
"[end-para]",
]
expected_gfm = """<p><a href="mailto:[email protected]">[email protected]</a></p>"""
# Act
actual_tokens = tokenizer.transform(source_markdown)
actual_gfm = transformer.transform(actual_tokens)
# Assert
assert_if_lists_different(expected_tokens, actual_tokens)
assert_if_strings_different(expected_gfm, actual_gfm)
assert_token_consistency(source_markdown, actual_tokens)
def test_list_items_293a():
"""
Test case 293a: variation on 293
"""
# Arrange
tokenizer = TokenizedMarkdown()
transformer = TransformToGfm()
source_markdown = """1. a
1. b
1. c"""
expected_tokens = [
"[olist(1,1):.:1:3:: ]",
"[para(1,4):]",
"[text:a:]",
"[end-para]",
"[li(2,3):5: ]",
"[para(2,6):\n ]",
"[text:b\n1. c::\n]",
"[end-para]",
"[end-olist]",
]
expected_gfm = """<ol>
<li>a</li>
<li>b
1. c</li>
</ol>"""
# Act
actual_tokens = tokenizer.transform(source_markdown)
actual_gfm = transformer.transform(actual_tokens)
# Assert
assert_if_lists_different(expected_tokens, actual_tokens)
assert_if_strings_different(expected_gfm, actual_gfm)
assert_token_consistency(source_markdown, actual_tokens)
def test_autolinks_603():
"""
Test case 603: (part 2) Here are some valid autolinks:
"""
# Arrange
tokenizer = TokenizedMarkdown()
transformer = TransformToGfm()
source_markdown = """<http://foo.bar.baz/test?q=hello&id=22&boolean>"""
expected_tokens = [
"[para(1,1):]",
"[uri-autolink:http://foo.bar.baz/test?q=hello&id=22&boolean]",
"[end-para]",
]
expected_gfm = """<p><a href="http://foo.bar.baz/test?q=hello&id=22&boolean">http://foo.bar.baz/test?q=hello&id=22&boolean</a></p>"""
# Act
actual_tokens = tokenizer.transform(source_markdown)
actual_gfm = transformer.transform(actual_tokens)
# Assert
assert_if_lists_different(expected_tokens, actual_tokens)
assert_if_strings_different(expected_gfm, actual_gfm)
assert_token_consistency(source_markdown, actual_tokens)
def test_image_link_586():
"""
Test case 586: (part 3) Only the plain string content is rendered, without formatting.
"""
# Arrange
tokenizer = TokenizedMarkdown()
transformer = TransformToGfm()
source_markdown = """"""
expected_tokens = [
"[para(1,1):]",
"[image:inline:train.jpg::foo::::foo]",
"[end-para]",
]
expected_gfm = """<p><img src="train.jpg" alt="foo" /></p>"""
# Act
actual_tokens = tokenizer.transform(source_markdown)
actual_gfm = transformer.transform(actual_tokens)
# Assert
assert_if_lists_different(expected_tokens, actual_tokens)
assert_if_strings_different(expected_gfm, actual_gfm)
assert_token_consistency(source_markdown, actual_tokens)
def test_autolinks_605():
"""
Test case 605: Uppercase is also fine
"""
# Arrange
tokenizer = TokenizedMarkdown()
transformer = TransformToGfm()
source_markdown = """<MAILTO:[email protected]>"""
expected_tokens = [
"[para(1,1):]",
"[uri-autolink:MAILTO:[email protected]]",
"[end-para]",
]
expected_gfm = """<p><a href="MAILTO:[email protected]">MAILTO:[email protected]</a></p>"""
# Act
actual_tokens = tokenizer.transform(source_markdown)
actual_gfm = transformer.transform(actual_tokens)
# Assert
assert_if_lists_different(expected_tokens, actual_tokens)
assert_if_strings_different(expected_gfm, actual_gfm)
assert_token_consistency(source_markdown, actual_tokens)
def test_block_quotes_214():
"""
Test case 214: (part 1) For the same reason, we can’t omit the > in front of subsequent lines of an indented or fenced code block:
"""
# TODO add case with >
# Arrange
tokenizer = TokenizedMarkdown()
transformer = TransformToGfm()
source_markdown = """> foo
bar"""
expected_tokens = [
"[block-quote(1,1):]",
"[icode-block(1,7): :]",
"[text:foo:]",
"[end-icode-block]",
"[end-block-quote]",
"[icode-block(2,5): :]",
"[text:bar:]",
"[end-icode-block]",
]
expected_gfm = """<blockquote>
<pre><code>foo
</code></pre>
</blockquote>
<pre><code>bar
</code></pre>"""
# Act
actual_tokens = tokenizer.transform(source_markdown)
actual_gfm = transformer.transform(actual_tokens)
# Assert
assert_if_lists_different(expected_tokens, actual_tokens)
assert_if_strings_different(expected_gfm, actual_gfm)
assert_token_consistency(source_markdown, actual_tokens)
