loofah 2.2.3 → 2.19.0

data/test/integration/test_html.rb

@@ -1,72 +0,0 @@
-require "helper"
-
-class IntegrationTestHtml < Loofah::TestCase
-  context "html fragment" do
-    context "#to_s" do
-      it "not include head tags (like style)" do
-        skip "depends on nokogiri version"
-        html = Loofah.fragment "<style>foo</style><div>bar</div>"
-        assert_equal "<div>bar</div>", html.to_s
-      end
-    end
-
-    context "#text" do
-      it "not include head tags (like style)" do
-        skip "depends on nokogiri version"
-        html = Loofah.fragment "<style>foo</style><div>bar</div>"
-        assert_equal "bar", html.text
-      end
-    end
-
-    context "#to_text" do
-      it "add newlines before and after html4 block elements" do
-        html = Loofah.fragment "<div>tweedle<h1>beetle</h1>bottle<span>puddle</span>paddle<div>battle</div>muddle</div>"
-        assert_equal "\ntweedle\nbeetle\nbottlepuddlepaddle\nbattle\nmuddle\n", html.to_text
-      end
-
-      it "add newlines before and after html5 block elements" do
-        html = Loofah.fragment "<div>tweedle<section>beetle</section>bottle<span>puddle</span>paddle<div>battle</div>muddle</div>"
-        assert_equal "\ntweedle\nbeetle\nbottlepuddlepaddle\nbattle\nmuddle\n", html.to_text
-      end
-
-      it "remove extraneous whitespace" do
-        html = Loofah.fragment "<div>tweedle\n\n\t\n\s\nbeetle</div>"
-        assert_equal "\ntweedle\n\nbeetle\n", html.to_text
-      end
-    end
-
-    context 'with an `encoding` arg' do
-      it "sets the parent document's encoding to accordingly" do
-        html = Loofah.fragment "<style>foo</style><div>bar</div>", 'US-ASCII'
-        assert_equal 'US-ASCII', html.document.encoding
-      end
-    end
-  end
-
-  context "html document" do
-    context "#text" do
-      it "not include head tags (like style)" do
-        html = Loofah.document "<style>foo</style><div>bar</div>"
-        assert_equal "bar", html.text
-      end
-    end
-
-    context "#to_text" do
-      it "add newlines before and after html4 block elements" do
-        html = Loofah.document "<div>tweedle<h1>beetle</h1>bottle<span>puddle</span>paddle<div>battle</div>muddle</div>"
-        assert_equal "\ntweedle\nbeetle\nbottlepuddlepaddle\nbattle\nmuddle\n", html.to_text
-      end
-
-      it "add newlines before and after html5 block elements" do
-        html = Loofah.document "<div>tweedle<section>beetle</section>bottle<span>puddle</span>paddle<div>battle</div>muddle</div>"
-        assert_equal "\ntweedle\nbeetle\nbottlepuddlepaddle\nbattle\nmuddle\n", html.to_text
-      end
-
-      it "remove extraneous whitespace" do
-        html = Loofah.document "<div>tweedle\n\n\t\n\s\nbeetle</div>"
-        assert_equal "\ntweedle\n\nbeetle\n", html.to_text
-      end
-    end
-  end
-end
-

data/test/integration/test_scrubbers.rb

@@ -1,400 +0,0 @@
-require "helper"
-
-class IntegrationTestScrubbers < Loofah::TestCase
-
-  INVALID_FRAGMENT = "<invalid>foo<p>bar</p>bazz</invalid><div>quux</div>"
-  INVALID_ESCAPED  = "&lt;invalid&gt;foo&lt;p&gt;bar&lt;/p&gt;bazz&lt;/invalid&gt;<div>quux</div>"
-  INVALID_PRUNED   = "<div>quux</div>"
-  INVALID_STRIPPED = "foo<p>bar</p>bazz<div>quux</div>"
-
-  WHITEWASH_FRAGMENT = "<o:div>no</o:div><div id='no'>foo</div><invalid>bar</invalid><!--[if gts mso9]><div>microsofty stuff</div><![endif]-->"
-  WHITEWASH_RESULT   = "<div>foo</div>"
-
-  NOFOLLOW_FRAGMENT = '<a href="http://www.example.com/">Click here</a>'
-  NOFOLLOW_RESULT   = '<a href="http://www.example.com/" rel="nofollow">Click here</a>'
-
-  NOFOLLOW_WITH_REL_FRAGMENT = '<a href="http://www.example.com/" rel="noopener">Click here</a>'
-  NOFOLLOW_WITH_REL_RESULT   = '<a href="http://www.example.com/" rel="noopener nofollow">Click here</a>'
-
-  NOOPENER_FRAGMENT = '<a href="http://www.example.com/">Click here</a>'
-  NOOPENER_RESULT   = '<a href="http://www.example.com/" rel="noopener">Click here</a>'
-
-  NOOPENER_WITH_REL_FRAGMENT = '<a href="http://www.example.com/" rel="nofollow">Click here</a>'
-  NOOPENER_WITH_REL_RESULT   = '<a href="http://www.example.com/" rel="nofollow noopener">Click here</a>'
-
-  UNPRINTABLE_FRAGMENT = "<b>Lo\u2029ofah ro\u2028cks!</b><script>x\u2028y</script>"
-  UNPRINTABLE_RESULT = "<b>Loofah rocks!</b><script>xy</script>"
-
-  ENTITY_FRAGMENT   = "<p>this is &lt; that &quot;&amp;&quot; the other &gt; boo&apos;ya</p><div>w00t</div>"
-  ENTITY_TEXT       = %Q(this is < that "&" the other > boo\'yaw00t)
-
-  ENTITY_HACK_ATTACK            = "<div><div>Hack attack!</div><div>&lt;script&gt;alert('evil')&lt;/script&gt;</div></div>"
-  ENTITY_HACK_ATTACK_TEXT_SCRUB = "Hack attack!&lt;script&gt;alert('evil')&lt;/script&gt;"
-  ENTITY_HACK_ATTACK_TEXT_SCRUB_UNESC = "Hack attack!<script>alert('evil')</script>"
-
-  context "Document" do
-    context "#scrub!" do
-      context ":escape" do
-        it "escape bad tags" do
-          doc = Loofah::HTML::Document.parse "<html><body>#{INVALID_FRAGMENT}</body></html>"
-          result = doc.scrub! :escape
-
-          assert_equal INVALID_ESCAPED, doc.xpath('/html/body').inner_html
-          assert_equal doc, result
-        end
-      end
-
-      context ":prune" do
-        it "prune bad tags" do
-          doc = Loofah::HTML::Document.parse "<html><body>#{INVALID_FRAGMENT}</body></html>"
-          result = doc.scrub! :prune
-
-          assert_equal INVALID_PRUNED, doc.xpath('/html/body').inner_html
-          assert_equal doc, result
-        end
-      end
-
-      context ":strip" do
-        it "strip bad tags" do
-          doc = Loofah::HTML::Document.parse "<html><body>#{INVALID_FRAGMENT}</body></html>"
-          result = doc.scrub! :strip
-
-          assert_equal INVALID_STRIPPED, doc.xpath('/html/body').inner_html
-          assert_equal doc, result
-        end
-      end
-
-      context ":whitewash" do
-        it "whitewash the markup" do
-          doc = Loofah::HTML::Document.parse "<html><body>#{WHITEWASH_FRAGMENT}</body></html>"
-          result = doc.scrub! :whitewash
-
-          assert_equal WHITEWASH_RESULT, doc.xpath('/html/body').inner_html
-          assert_equal doc, result
-        end
-      end
-
-      context ":nofollow" do
-        it "add a 'nofollow' attribute to hyperlinks" do
-          doc = Loofah::HTML::Document.parse "<html><body>#{NOFOLLOW_FRAGMENT}</body></html>"
-          result = doc.scrub! :nofollow
-
-          assert_equal NOFOLLOW_RESULT, doc.xpath('/html/body').inner_html
-          assert_equal doc, result
-        end
-      end
-
-      context ":unprintable" do
-        it "removes unprintable unicode characters" do
-          doc = Loofah::HTML::Document.parse "<html><body>#{UNPRINTABLE_FRAGMENT}</body></html>"
-          result = doc.scrub! :unprintable
-
-          assert_equal UNPRINTABLE_RESULT, doc.xpath("/html/body").inner_html
-          assert_equal doc, result
-        end
-      end
-    end
-
-    context "#scrub_document" do
-      it "be a shortcut for parse-and-scrub" do
-        mock_doc = Object.new
-        mock(Loofah).document(:string_or_io) { mock_doc }
-        mock(mock_doc).scrub!(:method)
-
-        Loofah.scrub_document(:string_or_io, :method)
-      end
-    end
-
-    context "#text" do
-      it "leave behind only inner text with html entities still escaped" do
-        doc = Loofah::HTML::Document.parse "<html><body>#{ENTITY_HACK_ATTACK}</body></html>"
-        result = doc.text
-
-        assert_equal ENTITY_HACK_ATTACK_TEXT_SCRUB, result
-      end
-
-      context "with encode_special_chars => false" do
-        it "leave behind only inner text with html entities unescaped" do
-          doc = Loofah::HTML::Document.parse "<html><body>#{ENTITY_HACK_ATTACK}</body></html>"
-          result = doc.text(:encode_special_chars => false)
-
-          assert_equal ENTITY_HACK_ATTACK_TEXT_SCRUB_UNESC, result
-        end
-      end
-
-      context "with encode_special_chars => true" do
-        it "leave behind only inner text with html entities still escaped" do
-          doc = Loofah::HTML::Document.parse "<html><body>#{ENTITY_HACK_ATTACK}</body></html>"
-          result = doc.text(:encode_special_chars => true)
-
-          assert_equal ENTITY_HACK_ATTACK_TEXT_SCRUB, result
-        end
-      end
-    end
-
-    context "#to_s" do
-      it "generate HTML" do
-        doc = Loofah.scrub_document "<html><head><title>quux</title></head><body><div>foo</div></body></html>", :prune
-        refute_nil doc.xpath("/html").first
-        refute_nil doc.xpath("/html/head").first
-        refute_nil doc.xpath("/html/body").first
-
-        string = doc.to_s
-        assert_match %r/<!DOCTYPE/, string
-        assert_match %r/<html>/, string
-        assert_match %r/<head>/, string
-        assert_match %r/<body>/, string
-      end
-    end
-
-    context "#serialize" do
-      it "generate HTML" do
-        doc = Loofah.scrub_document "<html><head><title>quux</title></head><body><div>foo</div></body></html>", :prune
-        refute_nil doc.xpath("/html").first
-        refute_nil doc.xpath("/html/head").first
-        refute_nil doc.xpath("/html/body").first
-
-        string = doc.serialize
-        assert_match %r/<!DOCTYPE/, string
-        assert_match %r/<html>/, string
-        assert_match %r/<head>/, string
-        assert_match %r/<body>/, string
-      end
-    end
-
-    context "Node" do
-      context "#scrub!" do
-        it "only scrub subtree" do
-          xml = Loofah.document <<-EOHTML
-           <html><body>
-             <div class='scrub'>
-               <script>I should be removed</script>
-             </div>
-             <div class='noscrub'>
-               <script>I should remain</script>
-             </div>
-           </body></html>
-          EOHTML
-          node = xml.at_css "div.scrub"
-          node.scrub!(:prune)
-          assert_match %r/I should remain/,     xml.to_s
-          refute_match %r/I should be removed/, xml.to_s
-        end
-      end
-    end
-
-    context "NodeSet" do
-      context "#scrub!" do
-        it "only scrub subtrees" do
-          xml = Loofah.document <<-EOHTML
-            <html><body>
-              <div class='scrub'>
-                <script>I should be removed</script>
-              </div>
-              <div class='noscrub'>
-                <script>I should remain</script>
-              </div>
-              <div class='scrub'>
-                <script>I should also be removed</script>
-              </div>
-            </body></html>
-          EOHTML
-          node_set = xml.css "div.scrub"
-          assert_equal 2, node_set.length
-          node_set.scrub!(:prune)
-          assert_match %r/I should remain/,          xml.to_s
-          refute_match %r/I should be removed/,      xml.to_s
-          refute_match %r/I should also be removed/, xml.to_s
-        end
-      end
-    end
-  end
-
-  context "DocumentFragment" do
-    context "#scrub!" do
-      context ":escape" do
-        it "escape bad tags" do
-          doc = Loofah::HTML::DocumentFragment.parse "<div>#{INVALID_FRAGMENT}</div>"
-          result = doc.scrub! :escape
-
-          assert_equal INVALID_ESCAPED, doc.xpath("./div").inner_html
-          assert_equal doc, result
-        end
-      end
-
-      context ":prune" do
-        it "prune bad tags" do
-          doc = Loofah::HTML::DocumentFragment.parse "<div>#{INVALID_FRAGMENT}</div>"
-          result = doc.scrub! :prune
-
-          assert_equal INVALID_PRUNED, doc.xpath("./div").inner_html
-          assert_equal doc, result
-        end
-      end
-
-      context ":strip" do
-        it "strip bad tags" do
-          doc = Loofah::HTML::DocumentFragment.parse "<div>#{INVALID_FRAGMENT}</div>"
-          result = doc.scrub! :strip
-
-          assert_equal INVALID_STRIPPED, doc.xpath("./div").inner_html
-          assert_equal doc, result
-        end
-      end
-
-      context ":whitewash" do
-        it "whitewash the markup" do
-          doc = Loofah::HTML::DocumentFragment.parse "<div>#{WHITEWASH_FRAGMENT}</div>"
-          result = doc.scrub! :whitewash
-
-          assert_equal WHITEWASH_RESULT, doc.xpath("./div").inner_html
-          assert_equal doc, result
-        end
-      end
-
-      context ":nofollow" do
-
-        context "for a hyperlink that does not have a rel attribute" do
-          it "add a 'nofollow' attribute to hyperlinks" do
-            doc = Loofah::HTML::DocumentFragment.parse "<div>#{NOFOLLOW_FRAGMENT}</div>"
-            result = doc.scrub! :nofollow
-
-            assert_equal NOFOLLOW_RESULT, doc.xpath("./div").inner_html
-            assert_equal doc, result
-          end
-        end
-
-        context "for a hyperlink that does have a rel attribute" do
-          it "appends nofollow to rel attribute" do
-              doc = Loofah::HTML::DocumentFragment.parse "<div>#{NOFOLLOW_WITH_REL_FRAGMENT}</div>"
-              result = doc.scrub! :nofollow
-
-              assert_equal NOFOLLOW_WITH_REL_RESULT, doc.xpath("./div").inner_html
-              assert_equal doc, result
-          end
-        end
-
-
-      end
-
-      context ":noopener" do
-        context "for a hyperlink without a 'rel' attribute" do
-          it "add a 'noopener' attribute to hyperlinks" do
-            doc = Loofah::HTML::DocumentFragment.parse "<div>#{NOOPENER_FRAGMENT}</div>"
-            result = doc.scrub! :noopener
-
-            assert_equal NOOPENER_RESULT, doc.xpath("./div").inner_html
-            assert_equal doc, result
-          end
-        end
-
-        context "for a hyperlink that does have a rel attribute" do
-          it "appends 'noopener' to 'rel' attribute" do
-            doc = Loofah::HTML::DocumentFragment.parse "<div>#{NOOPENER_WITH_REL_FRAGMENT}</div>"
-            result = doc.scrub! :noopener
-
-            assert_equal NOOPENER_WITH_REL_RESULT, doc.xpath("./div").inner_html
-            assert_equal doc, result
-          end
-        end
-      end
-
-      context ":unprintable" do
-        it "removes unprintable unicode characters" do
-          doc = Loofah::HTML::DocumentFragment.parse "<div>#{UNPRINTABLE_FRAGMENT}</div>"
-          result = doc.scrub! :unprintable
-
-          assert_equal UNPRINTABLE_RESULT, doc.xpath("./div").inner_html
-          assert_equal doc, result
-        end
-      end
-    end
-
-    context "#scrub_fragment" do
-      it "be a shortcut for parse-and-scrub" do
-        mock_doc = Object.new
-        mock(Loofah).fragment(:string_or_io) { mock_doc }
-        mock(mock_doc).scrub!(:method)
-
-        Loofah.scrub_fragment(:string_or_io, :method)
-      end
-    end
-
-    context "#text" do
-      it "leave behind only inner text with html entities still escaped" do
-        doc = Loofah::HTML::DocumentFragment.parse "<div>#{ENTITY_HACK_ATTACK}</div>"
-        result = doc.text
-
-        assert_equal ENTITY_HACK_ATTACK_TEXT_SCRUB, result
-      end
-
-      context "with encode_special_chars => false" do
-        it "leave behind only inner text with html entities unescaped" do
-          doc = Loofah::HTML::DocumentFragment.parse "<div>#{ENTITY_HACK_ATTACK}</div>"
-          result = doc.text(:encode_special_chars => false)
-
-          assert_equal ENTITY_HACK_ATTACK_TEXT_SCRUB_UNESC, result
-        end
-      end
-
-      context "with encode_special_chars => true" do
-        it "leave behind only inner text with html entities still escaped" do
-          doc = Loofah::HTML::DocumentFragment.parse "<div>#{ENTITY_HACK_ATTACK}</div>"
-          result = doc.text(:encode_special_chars => true)
-
-          assert_equal ENTITY_HACK_ATTACK_TEXT_SCRUB, result
-        end
-      end
-    end
-
-    context "#to_s" do
-      it "not remove entities" do
-        string = Loofah.scrub_fragment(ENTITY_FRAGMENT, :prune).to_s
-        assert_match %r/this is &lt;/, string
-      end
-    end
-
-    context "Node" do
-      context "#scrub!" do
-        it "only scrub subtree" do
-          xml = Loofah.fragment <<-EOHTML
-            <div class='scrub'>
-              <script>I should be removed</script>
-            </div>
-            <div class='noscrub'>
-              <script>I should remain</script>
-            </div>
-          EOHTML
-          node = xml.at_css "div.scrub"
-          node.scrub!(:prune)
-          assert_match %r(I should remain),     xml.to_s
-          refute_match %r(I should be removed), xml.to_s
-        end
-      end
-    end
-
-    context "NodeSet" do
-      context "#scrub!" do
-        it "only scrub subtrees" do
-          xml = Loofah.fragment <<-EOHTML
-            <div class='scrub'>
-              <script>I should be removed</script>
-            </div>
-            <div class='noscrub'>
-              <script>I should remain</script>
-            </div>
-            <div class='scrub'>
-              <script>I should also be removed</script>
-            </div>
-          EOHTML
-          node_set = xml.css "div.scrub"
-          assert_equal 2, node_set.length
-          node_set.scrub!(:prune)
-          assert_match %r/I should remain/,          xml.to_s
-          refute_match %r/I should be removed/,      xml.to_s
-          refute_match %r/I should also be removed/, xml.to_s
-        end
-      end
-    end
-  end
-end

data/test/integration/test_xml.rb

@@ -1,55 +0,0 @@
-require "helper"
-
-class IntegrationTestXml < Loofah::TestCase
-  context "integration test" do
-    context "xml document" do
-      context "custom scrubber" do
-        it "act as expected" do
-          xml = Loofah.xml_document <<-EOXML
-            <root>
-              <employee deceased='true'>Abraham Lincoln</employee>
-              <employee deceased='false'>Abe Vigoda</employee>
-            </root>
-          EOXML
-          bring_out_your_dead = Loofah::Scrubber.new do |node|
-            if node.name == "employee" and node["deceased"] == "true"
-              node.remove
-              Loofah::Scrubber::STOP # don't bother with the rest of the subtree
-            end
-          end
-          assert_equal 2, xml.css("employee").length
-          
-          xml.scrub!(bring_out_your_dead)
-
-          employees = xml.css "employee"
-          assert_equal 1, employees.length
-          assert_equal "Abe Vigoda", employees.first.inner_text
-        end
-      end
-    end
-
-    context "xml fragment" do
-      context "custom scrubber" do
-        it "act as expected" do
-          xml = Loofah.xml_fragment <<-EOXML
-            <employee deceased='true'>Abraham Lincoln</employee>
-            <employee deceased='false'>Abe Vigoda</employee>
-          EOXML
-          bring_out_your_dead = Loofah::Scrubber.new do |node|
-            if node.name == "employee" and node["deceased"] == "true"
-              node.remove
-              Loofah::Scrubber::STOP # don't bother with the rest of the subtree
-            end
-          end
-          assert_equal 2, xml.css("employee").length
-          
-          xml.scrub!(bring_out_your_dead)
-
-          employees = xml.css "employee"
-          assert_equal 1, employees.length
-          assert_equal "Abe Vigoda", employees.first.inner_text
-        end
-      end
-    end
-  end
-end

data/test/unit/test_api.rb

@@ -1,142 +0,0 @@
-require "helper"
-
-class UnitTestApi < Loofah::TestCase
-
-  HTML          = "<div>a</div>\n<div>b</div>"
-  XML_FRAGMENT  = "<div>a</div>\n<div>b</div>"
-  XML           = "<root>#{XML_FRAGMENT}</root>"
-
-  describe "HTML" do
-    it "creates documents" do
-      doc = Loofah.document(HTML)
-      assert_html_documentish doc
-    end
-
-    it "creates fragments" do
-      doc = Loofah.fragment(HTML)
-      assert_html_fragmentish doc
-    end
-
-    it "parses documents" do
-      doc = Loofah::HTML::Document.parse(HTML)
-      assert_html_documentish doc
-    end
-
-    it "parses document fragment" do
-      doc = Loofah::HTML::DocumentFragment.parse(HTML)
-      assert_html_fragmentish doc
-    end
-
-    it "scrubs documents" do
-      doc = Loofah.document(HTML).scrub!(:strip)
-      assert_html_documentish doc
-    end
-
-    it "scrubs fragments" do
-      doc = Loofah.fragment(HTML).scrub!(:strip)
-      assert_html_fragmentish doc
-    end
-
-    it "scrubs document nodes" do
-      doc = Loofah.document(HTML)
-      assert(node = doc.at_css("div"))
-      node.scrub!(:strip)
-    end
-
-    it "scrubs fragment nodes" do
-      doc = Loofah.fragment(HTML)
-      assert(node = doc.at_css("div"))
-      node.scrub!(:strip)
-    end
-
-    it "scrubs document nodesets" do
-      doc = Loofah.document(HTML)
-      assert(node_set = doc.css("div"))
-      assert_instance_of Nokogiri::XML::NodeSet, node_set
-      node_set.scrub!(:strip)
-    end
-
-    it "exposes serialize_root on HTML::DocumentFragment" do
-      doc = Loofah.fragment(HTML)
-      assert_equal HTML, doc.serialize_root.to_html
-    end
-
-    it "exposes serialize_root on HTML::Document" do
-      doc = Loofah.document(HTML)
-      assert_equal HTML, doc.serialize_root.children.to_html
-    end
-  end
-
-  describe "XML" do
-    it "creates documents" do
-      doc = Loofah.xml_document(XML)
-      assert_xml_documentish doc
-    end
-
-    it "creates fragments" do
-      doc = Loofah.xml_fragment(XML_FRAGMENT)
-      assert_xml_fragmentish doc
-    end
-
-    it "parses documents" do
-      doc = Loofah::XML::Document.parse(XML)
-      assert_xml_documentish doc
-    end
-
-    it "parses document fragments" do
-      doc = Loofah::XML::DocumentFragment.parse(XML_FRAGMENT)
-      assert_xml_fragmentish doc
-    end
-
-    it "scrubs documents" do
-      scrubber = Loofah::Scrubber.new { |node| }
-      doc = Loofah.xml_document(XML).scrub!(scrubber)
-      assert_xml_documentish doc
-    end
-
-    it "scrubs fragments" do
-      scrubber = Loofah::Scrubber.new { |node| }
-      doc = Loofah.xml_fragment(XML_FRAGMENT).scrub!(scrubber)
-      assert_xml_fragmentish doc
-    end
-
-    it "scrubs document nodes" do
-      doc = Loofah.xml_document(XML)
-      assert(node = doc.at_css("div"))
-      node.scrub!(:strip)
-    end
-
-    it "scrubs fragment nodes" do
-      doc = Loofah.xml_fragment(XML)
-      assert(node = doc.at_css("div"))
-      node.scrub!(:strip)
-    end
-  end
-
-  private
-
-  def assert_html_documentish(doc)
-    assert_kind_of Nokogiri::HTML::Document, doc
-    assert_kind_of Loofah::HTML::Document,   doc
-    assert_equal HTML, doc.xpath("/html/body").inner_html
-  end
-
-  def assert_html_fragmentish(doc)
-    assert_kind_of Nokogiri::HTML::DocumentFragment, doc
-    assert_kind_of Loofah::HTML::DocumentFragment,   doc
-    assert_equal HTML, doc.inner_html
-  end
-
-  def assert_xml_documentish(doc)
-    assert_kind_of Nokogiri::XML::Document, doc
-    assert_kind_of Loofah::XML::Document,   doc
-    assert_equal XML, doc.root.to_xml
-  end
-
-  def assert_xml_fragmentish(doc)
-    assert_kind_of Nokogiri::XML::DocumentFragment, doc
-    assert_kind_of Loofah::XML::DocumentFragment,   doc
-    assert_equal XML_FRAGMENT, doc.children.to_xml
-  end
-
-end

data/test/unit/test_encoding.rb

@@ -1,20 +0,0 @@
-# :coding: utf-8
-require "helper"
-
-class UnitTestEncoding < Loofah::TestCase
-  UTF8_STRING = "日本語"
-
-  if String.new.respond_to?(:encoding)
-    describe "scrub_fragment" do
-      it "sets the encoding for html" do
-        escaped = Loofah.scrub_fragment(UTF8_STRING, :escape).to_s
-        assert_equal UTF8_STRING.encoding, escaped.encoding
-      end
-
-      it "sets the encoding for xml" do
-        escaped = Loofah.scrub_xml_fragment(UTF8_STRING, :escape).to_s
-        assert_equal UTF8_STRING.encoding, escaped.encoding
-      end
-    end
-  end
-end