etude_for_ruby 0.1.4 → 0.2.3

data/vendor/bundle/ruby/2.2.0/gems/redcarpet-3.4.0/test/html5_test.rb

@@ -1,82 +0,0 @@
-require 'test_helper'
-
-class HTML5Test < Redcarpet::TestCase
-  def test_that_html5_works
-    section = <<-HTML.chomp.strip_heredoc
-      <section>
-        <p>The quick brown fox jumps over the lazy dog.</p>
-      </section>
-    HTML
-
-    figure = <<-HTML.chomp.strip_heredoc
-      <figure>
-        <img src="http://example.org/image.jpg" alt="">
-        <figcaption>
-          <p>Hello world!</p>
-        </figcaption>
-      </figure>
-    HTML
-
-    assert_renders section, section
-    assert_renders figure, figure
-  end
-
-  def test_that_html5_works_with_code_blocks
-    section = <<-HTML
-\t<section>
-\t\t<p>The quick brown fox jumps over the lazy dog.</p>
-\t</section>
-    HTML
-
-    section_expected = <<-HTML.chomp.strip_heredoc
-      <pre><code>&lt;section&gt;
-          &lt;p&gt;The quick brown fox jumps over the lazy dog.&lt;/p&gt;
-      &lt;/section&gt;
-      </code></pre>
-    HTML
-
-    header = <<-HTML
-    <header>
-        <hgroup>
-            <h1>Section heading</h1>
-            <h2>Subhead</h2>
-        </hgroup>
-    </header>
-    HTML
-
-    header_expected = <<-HTML.chomp.strip_heredoc
-      <pre><code>&lt;header&gt;
-          &lt;hgroup&gt;
-              &lt;h1&gt;Section heading&lt;/h1&gt;
-              &lt;h2&gt;Subhead&lt;/h2&gt;
-          &lt;/hgroup&gt;
-      &lt;/header&gt;
-      </code></pre>
-    HTML
-
-    assert_renders section_expected, section
-    assert_renders header_expected, header
-  end
-
-  def test_script_tag_recognition
-    html = <<-HTML.chomp.strip_heredoc
-      <script type="text/javascript">
-        alert('Foo!');
-      </script>
-    HTML
-
-    assert_renders html, html
-  end
-
-  def test_new_html5_tags_not_escaped
-    details = <<-HTML.chomp.strip_heredoc
-      <details>
-        log:
-
-      </details>
-    HTML
-
-    assert_renders details, details
-  end
-
-end

data/vendor/bundle/ruby/2.2.0/gems/redcarpet-3.4.0/test/html_render_test.rb

@@ -1,268 +0,0 @@
-# coding: UTF-8
-require 'test_helper'
-
-class HTMLRenderTest < Redcarpet::TestCase
-  def setup
-    @renderer = Redcarpet::Render::HTML
-  end
-
-  # Hint: overrides filter_html, no_images and no_links
-  def test_that_escape_html_works
-    source = <<-HTML.strip_heredoc
-      Through <em>NO</em> <script>DOUBLE NO</script>
-
-      <script>BAD</script>
-
-      <img src="/favicon.ico" />
-    HTML
-    expected = <<-HTML.chomp.strip_heredoc
-      <p>Through &lt;em&gt;NO&lt;/em&gt; &lt;script&gt;DOUBLE NO&lt;/script&gt;</p>
-
-      <p>&lt;script&gt;BAD&lt;/script&gt;</p>
-
-      <p>&lt;img src=&quot;/favicon.ico&quot; /&gt;</p>
-    HTML
-
-    assert_equal expected, render(source, with: [:escape_html])
-  end
-
-  def test_that_filter_html_works
-    markdown = 'Through <em>NO</em> <script>DOUBLE NO</script>'
-    output   = render(markdown, with: [:filter_html])
-
-    assert_equal "<p>Through NO DOUBLE NO</p>", output
-  end
-
-  def test_filter_html_doesnt_break_two_space_hard_break
-    markdown = "Lorem,  \nipsum\n"
-    output   = render(markdown, with: [:filter_html])
-
-    assert_equal "<p>Lorem,<br>\nipsum</p>", output
-  end
-
-  def test_that_no_image_flag_works
-    markdown = %(![dust mite](http://dust.mite/image.png) <img src="image.png" />)
-    output   = render(markdown, with: [:no_images])
-
-    assert_no_match %r{<img}, output
-  end
-
-  def test_that_links_with_ampersands_work
-    markdown = %([/?a=b&c=d](/?a=b&c=d))
-    output   = render(markdown)
-    assert_equal "<p><a href=\"/?a=b&c=d\">/?a=b&amp;c=d</a></p>", output
-  end
-
-  def test_that_no_links_flag_works
-    markdown = %([This link](http://example.net/) <a href="links.html">links</a>)
-    output   = render(markdown, with: [:no_links])
-
-    assert_no_match %r{<a }, output
-  end
-
-  def test_that_safelink_flag_works
-    markdown = "[IRC](irc://chat.freenode.org/#freenode)"
-    output   = render(markdown, with: [:safe_links_only])
-
-    assert_equal "<p>[IRC](irc://chat.freenode.org/#freenode)</p>", output
-  end
-
-  def test_that_hard_wrap_works
-    markdown = <<-Markdown.strip_heredoc
-      Hello world,
-      this is just a simple test
-
-      With hard wraps
-      and other *things*.
-    Markdown
-    output   = render(markdown, with: [:hard_wrap])
-
-    assert_match %r{<br>}, output
-  end
-
-  def test_that_link_attributes_work
-    rndr = Redcarpet::Render::HTML.new(:link_attributes => {:rel => 'blank'})
-    md = Redcarpet::Markdown.new(rndr)
-    assert md.render('This is a [simple](http://test.com) test.').include?('rel="blank"')
-  end
-
-  def test_that_link_works_with_quotes
-    markdown = %([This'link"is](http://example.net/))
-    expected = %(<p><a href="http://example.net/">This&#39;link&quot;is</a></p>)
-
-    assert_equal expected, render(markdown)
-    assert_equal expected, render(markdown, with: [:escape_html])
-  end
-
-  def test_that_code_emphasis_work
-    markdown = <<-Markdown.strip_heredoc
-      This should be **`a bold codespan`**
-      However, this should be *`an emphasised codespan`*
-
-      * **`ABC`** or **`DEF`**
-      * Foo bar
-    Markdown
-
-    html = <<-HTML.chomp.strip_heredoc
-      <p>This should be <strong><code>a bold codespan</code></strong>
-      However, this should be <em><code>an emphasised codespan</code></em></p>
-
-      <ul>
-      <li><strong><code>ABC</code></strong> or <strong><code>DEF</code></strong></li>
-      <li>Foo bar</li>
-      </ul>
-    HTML
-
-    assert_equal html, render(markdown)
-  end
-
-  def test_that_parenthesis_are_handled_into_links
-    markdown = %(The [bash man page](man:bash(1))!)
-    expected = %(<p>The <a href="man:bash(1)">bash man page</a>!</p>)
-
-    assert_equal expected, render(markdown)
-  end
-
-  def test_autolinking_works_as_expected
-    markdown = "Uri ftp://user:pass@example.com/. Email foo@bar.com and link http://bar.com"
-    output   = render(markdown, with: [:autolink])
-
-    assert output.include? '<a href="ftp://user:pass@example.com/">ftp://user:pass@example.com/</a>'
-    assert output.include? 'mailto:foo@bar.com'
-    assert output.include? '<a href="http://bar.com">'
-  end
-
-  def test_that_footnotes_work
-    markdown = <<-Markdown.strip_heredoc
-      This is a footnote.[^1]
-
-      [^1]: It provides additional information.
-    Markdown
-
-    html = <<-HTML.chomp.strip_heredoc
-      <p>This is a footnote.<sup id="fnref1"><a href="#fn1" rel="footnote">1</a></sup></p>
-
-      <div class="footnotes">
-      <hr>
-      <ol>
-
-      <li id="fn1">
-      <p>It provides additional information.&nbsp;<a href="#fnref1" rev="footnote">&#8617;</a></p>
-      </li>
-
-      </ol>
-      </div>
-    HTML
-
-    output = render(markdown, with: [:footnotes])
-    assert_equal html, output
-  end
-
-  def test_footnotes_enabled_but_missing_marker
-    markdown = <<-Markdown.strip_heredoc
-      Some text without a marker
-
-      [^1] And a trailing definition
-    Markdown
-    html = <<-HTML.chomp.strip_heredoc
-      <p>Some text without a marker</p>
-
-      <p>[^1] And a trailing definition</p>
-    HTML
-
-    output = render(markdown, with: [:footnotes])
-    assert_equal html, output
-  end
-
-  def test_footnotes_enabled_but_missing_definition
-    markdown = "Some text with a marker[^1] but no definition."
-    expected = "<p>Some text with a marker[^1] but no definition.</p>"
-
-    output = render(markdown, with: [:footnotes])
-    assert_equal expected, output
-  end
-
-  def test_autolink_short_domains
-    markdown = "Example of uri ftp://auto/short/domains. Email auto@l.n and link http://a/u/t/o/s/h/o/r/t"
-    output   = render(markdown, with: [:autolink])
-
-    assert output.include? '<a href="ftp://auto/short/domains">ftp://auto/short/domains</a>'
-    assert output.include? 'mailto:auto@l.n'
-    assert output.include? '<a href="http://a/u/t/o/s/h/o/r/t">http://a/u/t/o/s/h/o/r/t</a>'
-  end
-
-  def test_that_prettify_works
-    markdown = "\tclass Foo\nend"
-    output   = render(markdown, with: [:prettify])
-
-    assert output.include?("<pre><code class=\"prettyprint\">")
-
-    markdown = "`class`"
-    output   = render(markdown, with: [:prettify])
-
-    assert output.include?("<code class=\"prettyprint\">")
-  end
-
-  def test_prettify_with_fenced_code_blocks
-    markdown = "~~~ruby\ncode\n~~~"
-    output   = render(markdown, with: [:fenced_code_blocks, :prettify])
-
-    assert output.include?("<code class=\"prettyprint lang-ruby\">")
-  end
-
-  def test_safe_links_only_with_anchors
-    markdown = "An [anchor link](#anchor) on a page."
-    output   = render(markdown, with: [:safe_links_only])
-
-    assert_match %r{<a href="#anchor">anchor link</a>}, output
-  end
-
-  def test_autolink_with_link_attributes
-    options = { autolink: true, link_attributes: {rel: "nofollow"} }
-    output  = render("https://github.com/", with: options)
-
-    assert_match %r{rel="nofollow"}, output
-  end
-
-  def test_image_unsafe_src_with_safe_links_only
-    markdown = "![foo](javascript:while(1);)"
-    output   = render(markdown, with: [:safe_links_only])
-
-    assert_not_match %r{img src}, output
-  end
-
-  def test_no_styles_option_inside_a_paragraph
-    markdown = "Hello <style> foo { bar: baz; } </style> !"
-    output   = render(markdown, with: [:no_styles])
-
-    assert_no_match %r{<style>}, output
-  end
-
-  def test_no_styles_inside_html_block_rendering
-    markdown = "<style> foo { bar: baz; } </style>"
-    output   = render(markdown, with: [:no_styles])
-
-    assert_no_match %r{<style>}, output
-  end
-
-  def test_non_ascii_removal_in_header_anchors
-    markdown = "# Glühlampe"
-    html = "<h1 id=\"gl-hlampe\">Glühlampe</h1>"
-
-    assert_equal html, render(markdown, with: [:with_toc_data])
-  end
-
-  def test_utf8_only_header_anchors
-    markdown = "# 見出し"
-    html = "<h1 id=\"part-37870bfa194139f\">見出し</h1>"
-
-    assert_equal html, render(markdown, with: [:with_toc_data])
-  end
-
-  def test_escape_entities_removal_from_anchor
-    output = render("# Foo's & Bar's", with: [:with_toc_data])
-    result = %(<h1 id="foos-bars">Foo&#39;s &amp; Bar&#39;s</h1>)
-
-    assert_equal result, output
-  end
-end

data/vendor/bundle/ruby/2.2.0/gems/redcarpet-3.4.0/test/html_toc_render_test.rb

@@ -1,82 +0,0 @@
-# coding: UTF-8
-require 'test_helper'
-
-class HTMLTOCRenderTest < Redcarpet::TestCase
-  def setup
-    @renderer = Redcarpet::Render::HTML_TOC
-    @markdown = <<-Markdown.strip_heredoc
-      # A title
-      ## A __nice__ subtitle
-      ## Another one
-      ### A sub-sub-title
-      ### 見出し
-    Markdown
-  end
-
-  def test_simple_toc_render
-    output = render(@markdown)
-
-    assert output.start_with?("<ul>")
-    assert output.end_with?("</ul>")
-
-    assert_equal 3, output.scan("<ul>").length
-    assert_equal 5, output.scan("<li>").length
-  end
-
-  def test_granular_toc_render
-    output = render(@markdown, with: { nesting_level: 2 })
-
-    assert output.start_with?("<ul>")
-    assert output.end_with?("</ul>")
-
-    assert_equal 3, output.scan("<li>").length
-    assert !output.include?("A sub-sub title")
-  end
-
-  def test_toc_heading_id
-    output = render(@markdown)
-
-    assert_match /a-title/, output
-    assert_match /a-nice-subtitle/, output
-    assert_match /another-one/, output
-    assert_match /a-sub-sub-title/, output
-    assert_match /part-37870bfa194139f/, output
-  end
-
-  def test_toc_heading_with_hyphen_and_equal
-    output = render("# Hello World\n\n-\n\n=")
-
-    assert_equal 1, output.scan("<li>").length
-    assert !output.include?('<a href=\"#\"></a>')
-  end
-
-  def test_anchor_generation_with_edge_cases
-    # Imported from ActiveSupport::Inflector#parameterize's tests
-    titles = {
-      "Donald E. Knuth"                     => "donald-e-knuth",
-      "Random text with *(bad)* characters" => "random-text-with-bad-characters",
-      "!@#Surrounding bad characters!@#"    => "surrounding-bad-characters",
-      "Squeeze   separators"                => "squeeze-separators",
-      "Test with + sign"                    => "test-with-sign",
-      "Test with a Namespaced::Class"       => "test-with-a-namespaced-class"
-    }
-
-    titles.each do |title, anchor|
-      assert_match %("##{anchor}"), render("# #{title}")
-    end
-  end
-
-  def test_inline_markup_is_not_escaped
-    output = render(@markdown)
-
-    assert_match "A <strong>nice</strong> subtitle", output
-    assert_no_match %r{&lt;}, output
-  end
-
-  def test_inline_markup_escaping
-    output = render(@markdown, with: [:escape_html])
-
-    assert_match "&lt;strong&gt;", output
-    assert_no_match %r{<strong>}, output
-  end
-end

data/vendor/bundle/ruby/2.2.0/gems/redcarpet-3.4.0/test/markdown_test.rb

@@ -1,406 +0,0 @@
-# coding: UTF-8
-require 'test_helper'
-
-class MarkdownTest < Redcarpet::TestCase
-  def setup
-    @renderer = Redcarpet::Render::HTML
-  end
-
-  def test_that_simple_one_liner_goes_to_html
-    assert_equal "<p>Hello World.</p>", render("Hello World.")
-  end
-
-  def test_that_inline_markdown_goes_to_html
-    assert_equal "<p><em>Hello World</em>!</p>", render('_Hello World_!')
-  end
-
-  def test_that_inline_markdown_starts_and_ends_correctly
-    output   = render('_start _ foo_bar bar_baz _ end_ *italic* **bold** <a>_blah_</a>', with: [:no_intra_emphasis])
-    expected = "<p><em>start _ foo_bar bar_baz _ end</em> <em>italic</em> <strong>bold</strong> <a><em>blah</em></a></p>"
-
-    assert_equal expected, output
-
-    output   = render("Run 'rake radiant:extensions:rbac_base:migrate'")
-    expected = "<p>Run &#39;rake radiant:extensions:rbac_base:migrate&#39;</p>"
-
-    assert_equal expected, output
-  end
-
-  def test_that_urls_are_not_doubly_escaped
-    output = render('[Page 2](/search?query=Markdown+Test&page=2)')
-    assert_equal "<p><a href=\"/search?query=Markdown+Test&page=2\">Page 2</a></p>", output
-  end
-
-  def test_simple_inline_html
-    output   = render("before\n\n<div>\n  foo\n</div>\n\nafter")
-    expected = "<p>before</p>\n\n<div>\n  foo\n</div>\n\n<p>after</p>"
-
-    assert_equal expected, output
-  end
-
-  def test_that_html_blocks_do_not_require_their_own_end_tag_line
-    output   = render("Para 1\n\n<div><pre>HTML block\n</pre></div>\n\nPara 2 [Link](#anchor)")
-    expected = "<p>Para 1</p>\n\n<div><pre>HTML block\n</pre></div>\n\n<p>Para 2 <a href=\"#anchor\">Link</a></p>"
-
-    assert_equal expected, output
-  end
-
-  # This isn't in the spec but is Markdown.pl behavior.
-  def test_block_quotes_preceded_by_spaces
-    output = render <<-Markdown.strip_heredoc
-      A wise man once said:
-
-
-       > Isn't it wonderful just to be alive.
-    Markdown
-    expected = <<-HTML.chomp.strip_heredoc
-      <p>A wise man once said:</p>
-
-      <blockquote>
-      <p>Isn&#39;t it wonderful just to be alive.</p>
-      </blockquote>
-    HTML
-
-    assert_equal expected, output
-  end
-
-  def test_para_before_block_html_should_not_wrap_in_p_tag
-    output   = render("Things to watch out for\n<ul>\n<li>Blah</li>\n</ul>", with: [:lax_spacing])
-    expected = "<p>Things to watch out for</p>\n\n<ul>\n<li>Blah</li>\n</ul>"
-
-    assert_equal expected, output
-  end
-
-  # https://github.com/vmg/redcarpet/issues/111
-  def test_p_with_less_than_4space_indent_should_not_be_part_of_last_list_item
-    text = <<-Markdown
-  * a
-  * b
-  * c
-
-  This paragraph is not part of the list.
-    Markdown
-    expected = <<-HTML.chomp.strip_heredoc
-      <ul>
-      <li>a</li>
-      <li>b</li>
-      <li>c</li>
-      </ul>
-
-      <p>This paragraph is not part of the list.</p>
-    HTML
-
-    assert_equal expected, render(text)
-  end
-
-  # http://github.com/rtomayko/rdiscount/issues/#issue/13
-  def test_headings_with_trailing_space
-    text = "The Ant-Sugar Tales \n"       +
-           "=================== \n\n"     +
-           "By Candice Yellowflower   \n"
-
-    assert_equal "<h1>The Ant-Sugar Tales </h1>\n\n<p>By Candice Yellowflower   </p>", render(text)
-  end
-
-  def test_that_intra_emphasis_works
-    assert_equal "<p>foo<em>bar</em>baz</p>", render("foo_bar_baz")
-    assert_equal "<p>foo_bar_baz</p>", render("foo_bar_baz", with: [:no_intra_emphasis])
-  end
-
-  def test_that_autolink_flag_works
-    output   = render("http://github.com/rtomayko/rdiscount", with: [:autolink])
-    expected = "<p><a href=\"http://github.com/rtomayko/rdiscount\">http://github.com/rtomayko/rdiscount</a></p>"
-
-    assert_equal expected, output
-  end
-
-  def test_that_tags_can_have_dashes_and_underscores
-    output   = render("foo <asdf-qwerty>bar</asdf-qwerty> and <a_b>baz</a_b>")
-    expected = "<p>foo <asdf-qwerty>bar</asdf-qwerty> and <a_b>baz</a_b></p>"
-
-    assert_equal expected, output
-  end
-
-  def test_link_syntax_is_not_processed_within_code_blocks
-    output   = render("    This is a code block\n    This is a link [[1]] inside\n")
-    expected = "<pre><code>This is a code block\nThis is a link [[1]] inside\n</code></pre>"
-
-    assert_equal expected, output
-  end
-
-  def test_whitespace_after_urls
-    output   = render("Japan: http://www.abc.net.au/news/events/japan-quake-2011/beforeafter.htm (yes, japan)", with: [:autolink])
-    expected = %(<p>Japan: <a href="http://www.abc.net.au/news/events/japan-quake-2011/beforeafter.htm">http://www.abc.net.au/news/events/japan-quake-2011/beforeafter.htm</a> (yes, japan)</p>)
-
-    assert_equal expected, output
-  end
-
-  def test_memory_leak_when_parsing_char_links
-    render(<<-leaks.strip_heredoc)
-      2. Identify the wild-type cluster and determine all clusters
-         containing or contained by it:
-
-             wildtype <- wildtype.cluster(h)
-             wildtype.mask <- logical(nclust)
-             wildtype.mask[c(contains(h, wildtype),
-                             wildtype,
-                             contained.by(h, wildtype))] <- TRUE
-
-         This could be more elegant.
-    leaks
-  end
-
-  def test_infinite_loop_in_header
-    assert_equal "<h1>Body</h1>", render(<<-header.strip_heredoc)
-      ######
-      #Body#
-      ######
-    header
-  end
-
-  def test_a_hyphen_and_a_equal_should_not_be_converted_to_heading
-    assert_equal "<p>-</p>", render("-")
-    assert_equal "<p>=</p>", render("=")
-  end
-
-  def test_that_tables_flag_works
-    text = <<-Markdown.strip_heredoc
-       aaa | bbbb
-      -----|------
-      hello|sailor
-    Markdown
-
-    assert render(text) !~ /<table/
-    assert render(text, with: [:tables]) =~ /<table/
-  end
-
-  def test_that_tables_work_with_org_table_syntax
-    text = <<-Markdown.strip_heredoc
-      | aaa | bbbb |
-      |-----+------|
-      |hello|sailor|
-    Markdown
-
-    assert render(text) !~ /<table/
-    assert render(text, with: [:tables]) =~ /<table/
-  end
-
-  def test_strikethrough_flag_works
-    text = "this is ~some~ striked ~~text~~"
-
-    assert render(text) !~ /<del/
-    assert render(text, with: [:strikethrough]) =~ /<del/
-  end
-
-  def test_underline_flag_works
-    text   = "this is *some* text that is _underlined_. ___boom___"
-    output = render(text, with: [:underline])
-
-    refute render(text).include? '<u>underlined</u>'
-
-    assert output.include? '<u>underlined</u>'
-    assert output.include? '<em>some</em>'
-  end
-
-  def test_highlight_flag_works
-    text   = "this is ==highlighted=="
-    output = render(text, with: [:highlight])
-
-    refute render(text).include? '<mark>highlighted</mark>'
-
-    assert output.include? '<mark>highlighted</mark>'
-  end
-
-  def test_quote_flag_works
-    text   = 'this is a "quote"'
-    output = render(text, with: [:quote])
-
-    refute render(text).include? '<q>quote</q>'
-
-    assert_equal '<p>this is a <q>quote</q></p>', output
-  end
-
-  def test_that_fenced_flag_works
-    text = <<-fenced.strip_heredoc
-      This is a simple test
-
-      ~~~~~
-      This is some awesome code
-          with tabs and shit
-      ~~~
-    fenced
-
-    assert render(text) !~ /<code/
-    assert render(text, with: [:fenced_code_blocks]) =~ /<code/
-  end
-
-  def test_that_fenced_flag_works_without_space
-    text   = "foo\nbar\n```\nsome\ncode\n```\nbaz"
-    output = render(text, with: [:fenced_code_blocks, :lax_spacing])
-
-    assert output.include?("<pre><code>")
-
-    output = render(text, with: [:fenced_code_blocks])
-    assert !output.include?("<pre><code>")
-  end
-
-  def test_that_indented_code_preserves_references
-    text = <<-indented.strip_heredoc
-      This is normal text
-
-          Link to [Google][1]
-
-          [1]: http://google.com
-    indented
-
-    output = render(text, with: [:fenced_code_blocks])
-    assert output.include?("[1]: http://google.com")
-  end
-
-  def test_that_fenced_flag_preserves_references
-    text = <<-fenced.strip_heredoc
-      This is normal text
-
-      ```
-      Link to [Google][1]
-
-      [1]: http://google.com
-      ```
-    fenced
-
-    out = render(text, with: [:fenced_code_blocks])
-    assert out.include?("[1]: http://google.com")
-  end
-
-  def test_that_fenced_code_copies_language_verbatim_with_braces
-    text = "```{rust,no_run}\nx = 'foo'\n```"
-    html = render(text, with: [:fenced_code_blocks])
-
-    assert_equal "<pre><code class=\"rust,no_run\">x = &#39;foo&#39;\n</code></pre>", html
-  end
-
-  def test_that_fenced_code_copies_language_verbatim
-    text = "```rust,no_run\nx = 'foo'\n```"
-    html = render(text, with: [:fenced_code_blocks])
-
-    assert_equal "<pre><code class=\"rust,no_run\">x = &#39;foo&#39;\n</code></pre>", html
-  end
-
-  def test_that_indented_flag_works
-    text = <<-indented.strip_heredoc
-      This is a simple text
-
-          This is some awesome code
-          with shit
-
-      And this is again a simple text
-    indented
-
-    assert render(text) =~ /<code/
-    assert render(text, with: [:disable_indented_code_blocks]) !~ /<code/
-  end
-
-  def test_that_headers_are_linkable
-    output   = render('### Hello [GitHub](http://github.com)')
-    expected = "<h3>Hello <a href=\"http://github.com\">GitHub</a></h3>"
-
-    assert_equal expected, output
-  end
-
-  def test_autolinking_with_ent_chars
-    markdown = <<-Markdown.strip_heredoc
-      This a stupid link: https://github.com/rtomayko/tilt/issues?milestone=1&state=open
-    Markdown
-    output   = render(markdown, with: [:autolink])
-
-    assert_equal "<p>This a stupid link: <a href=\"https://github.com/rtomayko/tilt/issues?milestone=1&state=open\">https://github.com/rtomayko/tilt/issues?milestone=1&amp;state=open</a></p>", output
-  end
-
-  def test_spaced_headers
-    output = render("#123 a header yes\n", with: [:space_after_headers])
-
-    assert output !~ /<h1>/
-  end
-
-  def test_proper_intra_emphasis
-    assert render("http://en.wikipedia.org/wiki/Dave_Allen_(comedian)", with: [:no_intra_emphasis]) !~ /<em>/
-    assert render("this fails: hello_world_", with: [:no_intra_emphasis]) !~ /<em>/
-    assert render("this also fails: hello_world_#bye", with: [:no_intra_emphasis]) !~ /<em>/
-    assert render("this works: hello_my_world", with: [:no_intra_emphasis]) !~ /<em>/
-    assert render("句中**粗體**測試", with: [:no_intra_emphasis]) =~ /<strong>/
-
-    markdown = "This is (**bold**) and this_is_not_italic!"
-    output   = "<p>This is (<strong>bold</strong>) and this_is_not_italic!</p>"
-
-    assert_equal output, render(markdown, with: [:no_intra_emphasis])
-
-    markdown = "This is \"**bold**\""
-    output   = "<p>This is &quot;<strong>bold</strong>&quot;</p>"
-    assert_equal output, render(markdown, with: [:no_intra_emphasis])
-  end
-
-  def test_emphasis_escaping
-    assert_equal "<p><strong>foo*</strong> <em>dd_dd</em></p>", render("**foo\\*** _dd\\_dd_")
-  end
-
-  def test_char_escaping_when_highlighting
-    output = render("==attribute\\===", with: [:highlight])
-
-    assert_equal "<p><mark>attribute=</mark></p>", output
-  end
-
-  def test_ordered_lists_with_lax_spacing
-    output = render("Foo:\n1. Foo\n2. Bar", with: [:lax_spacing])
-
-    assert_match /<ol>/, output
-    assert_match /<li>Foo<\/li>/, output
-  end
-
-  def test_references_with_tabs_after_colon
-    output = render("[Link][id]\n[id]:\t\t\thttp://google.es")
-
-    assert_equal "<p><a href=\"http://google.es\">Link</a></p>", output
-  end
-
-  def test_superscript
-    output = render("this is the 2^nd time", with: [:superscript])
-
-    assert_equal "<p>this is the 2<sup>nd</sup> time</p>", output
-  end
-
-  def test_superscript_enclosed_in_parenthesis
-    output = render("this is the 2^(nd) time", with: [:superscript])
-
-    assert_equal "<p>this is the 2<sup>nd</sup> time</p>", output
-  end
-
-  def test_no_rewind_into_previous_inline
-    result = "<p><em>!dl</em><a href=\"mailto:1@danlec.com\">1@danlec.com</a></p>"
-    output = render("_!dl_1@danlec.com", with: [:autolink])
-
-    assert_equal result, output
-
-    result = "<p>abc123<em><a href=\"http://www.foo.com\">www.foo.com</a></em>@foo.com</p>"
-    output = render("abc123_www.foo.com_@foo.com", with: [:autolink])
-
-    assert_equal result, output
-  end
-
-  def test_autolink_with_period_next_to_url
-    result = %(<p>Checkout a cool site like <a href="https://github.com">https://github.com</a>.</p>)
-    output = render("Checkout a cool site like https://github.com.", with: [:autolink])
-
-    assert_equal result, output
-  end
-
-  def test_single_dashes_on_table_headers
-    markdown = <<-Markdown.strip_heredoc
-      | a | b |
-      | - | - |
-      | c | d |
-    Markdown
-    output   = render(markdown, with: [:tables])
-
-    assert_match /<table>/, output
-  end
-end