greenmat 3.2.2.2 → 3.5.1.2

data/test/custom_render_test.rb

@@ -4,16 +4,48 @@ require 'test_helper'
 class CustomRenderTest < Greenmat::TestCase
   class SimpleRender < Greenmat::Render::HTML
     def emphasis(text)
-      "<em class=\"cool\">#{text}</em>"
+      if @options[:no_intra_emphasis]
+        return %(<em class="no_intra_emphasis">#{text}</em>)
+      end
+
+      %(<em class="cool">#{text}</em>)
+    end
+
+    def header(text, level)
+      "My little poney" if @options[:with_toc_data]
     end
   end
 
   def test_simple_overload
     md = Greenmat::Markdown.new(SimpleRender)
-    html_equal "<p>This is <em class=\"cool\">just</em> a test</p>\n",
+    assert_equal "<p>This is <em class=\"cool\">just</em> a test</p>\n",
       md.render("This is *just* a test")
   end
 
+  def test_renderer_options
+    parser = Greenmat::Markdown.new(SimpleRender.new(with_toc_data: true))
+    output = parser.render("# A title")
+
+    assert_match "My little poney", output
+  end
+
+  def test_markdown_options
+    parser = Greenmat::Markdown.new(SimpleRender, no_intra_emphasis: true)
+    output = parser.render("*foo*")
+
+    assert_match "no_intra_emphasis", output
+  end
+
+  def test_original_options_hash_is_not_mutated
+    options = { with_toc_data: true }
+    render  = SimpleRender.new(options)
+    parser  = Greenmat::Markdown.new(render, tables: true)
+
+    computed_options = render.instance_variable_get(:"@options")
+
+    refute_equal computed_options.object_id, options.object_id
+  end
+
   class NilPreprocessRenderer < Greenmat::Render::HTML
     def preprocess(fulldoc)
       nil
@@ -25,4 +57,11 @@ class CustomRenderTest < Greenmat::TestCase
     assert_equal(nil,md.render("Anything"))
   end
 
+  def test_base_render_without_quote_callback
+    # Regression test for https://github.com/vmg/greenmat/issues/569
+    render = Class.new(Greenmat::Render::Base)
+    parser = Greenmat::Markdown.new render.new, quote: true
+
+    assert_equal "", parser.render(%(a "quote"))
+  end
 end

data/test/greenmat_bin_test.rb

@@ -0,0 +1,80 @@
+require 'test_helper'
+require 'tempfile'
+
+class GreenmatBinTest < Greenmat::TestCase
+  def setup
+    @fixture_file = Tempfile.new('bin')
+    @fixture_path = @fixture_file.path
+
+    @fixture_file.write "A ==simple== fixture file -- with " \
+                        "a [link](https://github.com)."
+    @fixture_file.rewind
+  end
+
+  def teardown
+    @fixture_file.unlink
+  end
+
+  def test_vanilla_bin
+    run_bin(@fixture_path)
+
+    expected = "<p>A ==simple== fixture file -- with " \
+               "a <a href=\"https://github.com\">link</a>.</p>\n"
+
+    assert_equal expected, @output
+  end
+
+  def test_enabling_a_parse_option
+    run_bin("--parse", "highlight", @fixture_path)
+
+    assert_output "<mark>"
+    refute_output "=="
+  end
+
+  def test_enabling_a_render_option
+    run_bin("--render", "no-links", @fixture_path)
+
+    assert_output "[link]"
+    refute_output "</a>"
+  end
+
+  def test_enabling_smarty_pants
+    run_bin("--smarty", @fixture_path)
+
+    assert_output "&ndash"
+    refute_output "--"
+  end
+
+  def test_version_option
+    run_bin("--version")
+    assert_output "Greenmat #{Greenmat::VERSION}"
+  end
+
+  def test_legacy_option_parsing
+    run_bin("--parse-highlight", "--render-no-links", @fixture_path)
+
+    assert_output "<mark>"
+    refute_output "=="
+
+    assert_output "[link]"
+    refute_output "</a>"
+  end
+
+  private
+
+  def run_bin(*args)
+    bin_path = File.expand_path('../../bin/greenmat', __FILE__)
+    ruby = RbConfig.ruby
+    IO.popen("#{ruby} #{bin_path} #{args.join(" ")}") do |stream|
+      @output = stream.read
+    end
+  end
+
+  def assert_output(pattern)
+    assert_match pattern, @output
+  end
+
+  def refute_output(pattern)
+    refute_match Regexp.new(pattern), @output
+  end
+end

data/test/greenmat_compat_test.rb

@@ -4,35 +4,35 @@ require 'test_helper'
 class GreenmatCompatTest < Greenmat::TestCase
   def test_simple_compat_api
     html = GreenmatCompat.new("This is_just_a test").to_html
-    html_equal "<p>This is<em>just</em>a test</p>\n", html
+    assert_equal "<p>This is<em>just</em>a test</p>\n", html
   end
 
   def test_compat_api_enables_extensions
     html = GreenmatCompat.new("This is_just_a test", :no_intra_emphasis).to_html
-    html_equal "<p>This is_just_a test</p>\n", html
+    assert_equal "<p>This is_just_a test</p>\n", html
   end
 
   def test_compat_api_knows_fenced_code_extension
     text = "```ruby\nx = 'foo'\n```"
     html = GreenmatCompat.new(text, :fenced_code).to_html
-    html_equal "<pre><code class=\"ruby\">x = 'foo'\n</code></pre>\n", html
+    assert_equal "<pre><code data-metadata=\"ruby\">x = &#39;foo&#39;\n</code></pre>\n", html
   end
 
   def test_compat_api_ignores_gh_blockcode_extension
     text = "```ruby\nx = 'foo'\n```"
     html = GreenmatCompat.new(text, :fenced_code, :gh_blockcode).to_html
-    html_equal "<pre><code class=\"ruby\">x = 'foo'\n</code></pre>\n", html
+    assert_equal "<pre><code data-metadata=\"ruby\">x = &#39;foo&#39;\n</code></pre>\n", html
   end
 
   def test_compat_api_knows_no_intraemphasis_extension
     html = GreenmatCompat.new("This is_just_a test", :no_intraemphasis).to_html
-    html_equal "<p>This is_just_a test</p>\n", html
+    assert_equal "<p>This is_just_a test</p>\n", html
   end
 
   def test_translate_outdated_extensions
     # these extensions are no longer used
     exts = [:gh_blockcode, :no_tables, :smart, :strict]
     html = GreenmatCompat.new('"TEST"', *exts).to_html
-    html_equal "<p>&quot;TEST&quot;</p>\n", html
+    assert_equal "<p>&quot;TEST&quot;</p>\n", html
   end
 end

data/test/html5_test.rb

@@ -2,68 +2,90 @@ require 'test_helper'
 
 class HTML5Test < Greenmat::TestCase
   def test_that_html5_works
-    section = <<EOS
-<section>
-  <p>The quick brown fox jumps over the lazy dog.</p>
-</section>
-EOS
+    section = <<-HTML.chomp.strip_heredoc
+      <section>
+        <p>The quick brown fox jumps over the lazy dog.</p>
+      </section>
+    HTML
 
-    figure = <<EOS
-<figure>
-  <img src="http://example.org/image.jpg" alt="">
-  <figcaption>
-    <p>Hello world!</p>
-  </figcaption>
-</figure>
-EOS
+    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 = <<EOS
+    section = <<-HTML
 \t<section>
 \t\t<p>The quick brown fox jumps over the lazy dog.</p>
 \t</section>
-EOS
+    HTML
 
-    section_expected = <<EOE
-<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>
-EOE
+    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 = <<EOS
+    header = <<-HTML
     <header>
         <hgroup>
             <h1>Section heading</h1>
             <h2>Subhead</h2>
         </hgroup>
     </header>
-EOS
+    HTML
 
-    header_expected = <<EOE
-<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>
-EOE
+    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
-    markdown = <<-Md
-<script type="text/javascript">
-  alert('Foo!');
-</script>
-Md
-    assert_renders markdown, markdown
+    html = <<-HTML.chomp.strip_heredoc
+      <script type="text/javascript">
+        alert('Foo!');
+      </script>
+    HTML
+
+    assert_renders html, html
+  end
+
+  def test_details_tags_ignoring
+    details = <<-HTML.chomp.strip_heredoc
+      <details><summary>Folding sample</summary><div>
+
+      ```rb
+      puts 'Hello, World'
+      ```
+      </div></details>
+    HTML
+    html = <<-HTML.chomp.strip_heredoc
+      <p><details><summary>Folding sample</summary><div></p>
+
+      <p><code>rb
+      puts &#39;Hello, World&#39;
+      </code>
+      </div></details></p>
+    HTML
+
+    assert_renders html, details
   end
 end

data/test/html_render_test.rb

@@ -3,79 +3,81 @@ require 'test_helper'
 
 class HTMLRenderTest < Greenmat::TestCase
   def setup
-    @markdown = Greenmat::Markdown.new(Greenmat::Render::HTML)
-    @rndr = {
-      :no_html => Greenmat::Render::HTML.new(:filter_html => true),
-      :no_images => Greenmat::Render::HTML.new(:no_images => true),
-      :no_links => Greenmat::Render::HTML.new(:no_links => true),
-      :safe_links => Greenmat::Render::HTML.new(:safe_links_only => true),
-      :escape_html => Greenmat::Render::HTML.new(:escape_html => true),
-      :hard_wrap => Greenmat::Render::HTML.new(:hard_wrap => true),
-      :toc_data => Greenmat::Render::HTML.new(:with_toc_data => true),
-      :prettify => Greenmat::Render::HTML.new(:prettify => true)
-    }
-  end
-
-  def render_with(rndr, text)
-    Greenmat::Markdown.new(rndr).render(text)
+    @renderer = Greenmat::Render::HTML
   end
 
   # Hint: overrides filter_html, no_images and no_links
   def test_that_escape_html_works
-    source = <<EOS
-Through <em>NO</em> <script>DOUBLE NO</script>
+    source = <<-HTML.strip_heredoc
+      Through <em>NO</em> <script>DOUBLE NO</script>
 
-<script>BAD</script>
+      <script>BAD</script>
 
-<img src="/favicon.ico" />
-EOS
-    expected = <<EOE
-<p>Through &lt;em&gt;NO&lt;/em&gt; &lt;script&gt;DOUBLE NO&lt;/script&gt;</p>
+      <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;script&gt;BAD&lt;/script&gt;</p>
 
-<p>&lt;img src=&quot;/favicon.ico&quot; /&gt;</p>
-EOE
+      <p>&lt;img src=&quot;/favicon.ico&quot; /&gt;</p>
+    HTML
 
-    markdown = render_with(@rndr[:escape_html], source)
-    html_equal expected, markdown
+    assert_equal expected, render(source, with: [:escape_html])
   end
 
   def test_that_filter_html_works
-    markdown = render_with(@rndr[:no_html], 'Through <em>NO</em> <script>DOUBLE NO</script>')
-    html_equal "<p>Through NO DOUBLE NO</p>\n", markdown
+    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 = render_with(@rndr[:no_html], "Lorem,  \nipsum\n")
-    html_equal "<p>Lorem,<br/>\nipsum</p>\n", markdown
+    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
-    rd = render_with(@rndr[:no_images], %(![dust mite](http://dust.mite/image.png) <img src="image.png" />))
-    assert rd !~ /<img/
+    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
-    rd = render_with(@rndr[:no_links], %([This link](http://example.net/) <a href="links.html">links</a>))
-    assert rd !~ /<a /
+    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
-    rd = render_with(@rndr[:safe_links], "[IRC](irc://chat.freenode.org/#freenode)")
-    html_equal "<p>[IRC](irc://chat.freenode.org/#freenode)</p>\n", rd
+    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
-    rd = render_with(@rndr[:hard_wrap], <<EOE)
-Hello world,
-this is just a simple test
+    markdown = <<-Markdown.strip_heredoc
+      Hello world,
+      this is just a simple test
 
-With hard wraps
-and other *things*.
-EOE
+      With hard wraps
+      and other *things*.
+    Markdown
+    output   = render(markdown, with: [:hard_wrap])
 
-    assert rd =~ /<br>/
+    assert_match %r{<br>}, output
   end
 
   def test_that_link_attributes_work
@@ -85,48 +87,45 @@ EOE
   end
 
   def test_that_link_works_with_quotes
-    rd = render_with(Greenmat::Render::HTML.new, %([This'link"is](http://example.net/)))
-    assert_equal "<p><a href=\"http://example.net/\">This&#39;link&quot;is</a></p>\n", rd
+    markdown = %([This'link"is](http://example.net/))
+    expected = %(<p><a href="http://example.net/">This&#39;link&quot;is</a></p>)
 
-    rd = render_with(@rndr[:escape_html], %([This'link"is](http://example.net/)))
-    assert_equal "<p><a href=\"http://example.net/\">This&#39;link&quot;is</a></p>\n", rd
+    assert_equal expected, render(markdown)
+    assert_equal expected, render(markdown, with: [:escape_html])
   end
 
   def test_that_code_emphasis_work
-    markdown = <<-MD
-This should be **`a bold codespan`**
-However, this should be *`an emphasised codespan`*
+    markdown = <<-Markdown.strip_heredoc
+      This should be **`a bold codespan`**
+      However, this should be *`an emphasised codespan`*
 
-* **`ABC`** or **`DEF`**
-* Foo bar
-MD
+      * **`ABC`** or **`DEF`**
+      * Foo bar
+    Markdown
 
-    html = <<HTML
-<p>This should be <strong><code>a bold codespan</code></strong>
-However, this should be <em><code>an emphasised codespan</code></em></p>
+    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
+      <ul>
+      <li><strong><code>ABC</code></strong> or <strong><code>DEF</code></strong></li>
+      <li>Foo bar</li>
+      </ul>
+    HTML
 
-    output = render_with(Greenmat::Render::HTML.new, markdown)
-    assert_equal html, output
+    assert_equal html, render(markdown)
   end
 
   def test_that_parenthesis_are_handled_into_links
-    markdown = "Hey have a look at the [bash man page](man:bash(1))!"
-    html = "<p>Hey have a look at the <a href=\"man:bash(1)\">bash man page</a>!</p>\n"
-    output = render_with(Greenmat::Render::HTML.new, markdown)
+    markdown = %(The [bash man page](man:bash(1))!)
+    expected = %(<p>The <a href="man:bash(1)">bash man page</a>!</p>)
 
-    assert_equal html, output
+    assert_equal expected, render(markdown)
   end
 
   def test_autolinking_works_as_expected
-    markdown = "Example of uri ftp://user:pass@example.com/. Email foo@bar.com and link http://bar.com"
-    renderer = Greenmat::Markdown.new(Greenmat::Render::HTML, :autolink => true)
-    output = renderer.render(markdown)
+    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'
@@ -134,107 +133,142 @@ HTML
   end
 
   def test_that_footnotes_work
-    markdown = <<-MD
-This is a footnote.[^1]
+    markdown = <<-Markdown.strip_heredoc
+      This is a footnote.[^1]
 
-[^1]: It provides additional information.
-MD
+      [^1]: It provides additional information.
+    Markdown
 
-    html = <<HTML
-<p>This is a footnote.<sup id="fnref1"><a href="#fn1" rel="footnote">1</a></sup></p>
+    html = <<-HTML.chomp.strip_heredoc
+      <p>This is a footnote.<sup id="fnref1"><a href="#fn1">1</a></sup></p>
 
-<div class="footnotes">
-<hr>
-<ol>
+      <div class="footnotes">
+      <hr>
+      <ol>
 
-<li id="fn1">
-<p>It provides additional information.&nbsp;<a href="#fnref1" rev="footnote">&#8617;</a></p>
-</li>
+      <li id="fn1">
+      <p>It provides additional information.&nbsp;<a href="#fnref1">&#8617;</a></p>
+      </li>
 
-</ol>
-</div>
-HTML
+      </ol>
+      </div>
+    HTML
 
-    renderer = Greenmat::Markdown.new(Greenmat::Render::HTML, :footnotes => true)
-    output = renderer.render(markdown)
+    output = render(markdown, with: [:footnotes])
     assert_equal html, output
   end
 
   def test_footnotes_enabled_but_missing_marker
-    markdown = <<MD
-Some text without a marker
+    markdown = <<-Markdown.strip_heredoc
+      Some text without a marker
 
-[^1] And a trailing definition
-MD
-    html = <<HTML
-<p>Some text without a marker</p>
+      [^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
+      <p>[^1] And a trailing definition</p>
+    HTML
 
-    renderer = Greenmat::Markdown.new(Greenmat::Render::HTML, :footnotes => true)
-    output = renderer.render(markdown)
+    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."
-    html = "<p>Some text with a marker[^1] but no definition.</p>\n"
+    expected = "<p>Some text with a marker[^1] but no definition.</p>"
 
-    renderer = Greenmat::Markdown.new(Greenmat::Render::HTML, :footnotes => true)
-    output = renderer.render(markdown)
-    assert_equal html, output
+    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"
-    renderer = Greenmat::Markdown.new(Greenmat::Render::HTML, :autolink => true)
-    output = renderer.render(markdown)
+    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_toc_heading_id
-    markdown = "# First level  heading\n## Second level heading"
-    output = render_with(@rndr[:toc_data], markdown)
-    assert_match /<h1 id="first-level-heading">/, output
-    assert_match /<h2 id="second-level-heading">/, output
-  end
-
   def test_that_prettify_works
-    text = <<-Markdown
-Foo
+    markdown = "\tclass Foo\nend"
+    output   = render(markdown, with: [:prettify])
+
+    assert output.include?("<pre><code class=\"prettyprint\">")
 
-~~~ruby
-some
-code
-~~~
+    markdown = "`class`"
+    output   = render(markdown, with: [:prettify])
 
-Bar
-Markdown
+    assert output.include?("<code class=\"prettyprint\">")
+  end
 
-    renderer = Greenmat::Markdown.new(@rndr[:prettify], fenced_code_blocks: true)
-    output = renderer.render(text)
+  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 ruby\">")
+    assert output.include?("<code class=\"prettyprint\" data-metadata=\"ruby\">")
   end
 
   def test_safe_links_only_with_anchors
     markdown = "An [anchor link](#anchor) on a page."
-
-    renderer = Greenmat::Markdown.new(@rndr[:safe_links])
-    output = renderer.render(markdown)
+    output   = render(markdown, with: [:safe_links_only])
 
     assert_match %r{<a href="#anchor">anchor link</a>}, output
   end
 
   def test_autolink_with_link_attributes
-    render = Greenmat::Render::HTML.new(link_attributes: {rel: "nofollow"})
-    parser = Greenmat::Markdown.new(render, autolink: true)
+    options = { autolink: true, link_attributes: {rel: "nofollow"} }
+    output  = render("https://github.com/", with: options)
 
-    output = parser.render("https://github.com/")
     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 = "# 見出し"
+    if 1.size == 4 # 32-bit architecture
+      html = "<h1 id=\"part-a194139f\">見出し</h1>"
+    elsif 1.size == 8 # 64-bit architecture
+      html = "<h1 id=\"part-37870bfa194139f\">見出し</h1>"
+    else
+      raise "unknown integer size"
+    end
+
+    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