daslabs 0.4.0

data/vendor/cache/ruby/2.5.0/gems/nokogiri-1.8.2/test/xml/test_c14n.rb

@@ -0,0 +1,180 @@
+require "helper"
+
+module Nokogiri
+  module XML
+    class TestC14N < Nokogiri::TestCase
+      # http://www.w3.org/TR/xml-c14n#Example-OutsideDoc
+      def test_3_1
+        doc = Nokogiri.XML <<-eoxml
+<?xml version="1.0"?>
+
+<?xml-stylesheet   href="doc.xsl"
+   type="text/xsl"   ?>
+
+<!DOCTYPE doc SYSTEM "doc.dtd">
+
+<doc>Hello, world!<!-- Comment 1 --></doc>
+
+<?pi-without-data     ?>
+
+<!-- Comment 2 -->
+
+<!-- Comment 3 -->
+        eoxml
+
+        c14n = doc.canonicalize
+        assert_no_match(/version=/, c14n)
+        assert_match(/Hello, world/, c14n)
+        assert_no_match(/Comment/, c14n)
+        c14n = doc.canonicalize(nil, nil, true)
+        assert_match(/Comment/, c14n)
+        c14n = doc.canonicalize(nil, nil, false)
+        assert_no_match(/Comment/, c14n)
+      end
+
+      def test_exclude_block_params
+        xml = '<a><b></b></a>'
+        doc = Nokogiri.XML xml
+
+        list = []
+        doc.canonicalize do |node, parent|
+          list << [node, parent]
+          true
+        end
+        if Nokogiri.jruby?
+          assert_equal(
+            ['a', 'document', 'document', nil, 'b', 'a'],
+            list.flatten.map { |x| x ? x.name : x }
+          )
+        else
+          assert_equal(
+            ['a', 'document', 'document', nil, 'b', 'a', 'a', 'document'],
+            list.flatten.map { |x| x ? x.name : x }
+          )
+        end
+      end
+
+      def test_exclude_block_true
+        xml = '<a><b></b></a>'
+        doc = Nokogiri.XML xml
+
+        c14n = doc.canonicalize do |node, parent|
+          true
+        end
+        assert_equal xml, c14n
+      end
+
+      def test_exclude_block_false
+        xml = '<a><b></b></a>'
+        doc = Nokogiri.XML xml
+
+        c14n = doc.canonicalize do |node, parent|
+          false
+        end
+        assert_equal '', c14n
+      end
+
+      def test_exclude_block_nil
+        xml = '<a><b></b></a>'
+        doc = Nokogiri.XML xml
+
+        c14n = doc.canonicalize do |node, parent|
+          nil
+        end
+        assert_equal '', c14n
+      end
+
+      def test_exclude_block_object
+        xml = '<a><b></b></a>'
+        doc = Nokogiri.XML xml
+
+        c14n = doc.canonicalize do |node, parent|
+          Object.new
+        end
+        assert_equal xml, c14n
+      end
+
+      def test_c14n_node
+        xml = '<a><b><c></c></b></a>'
+        doc = Nokogiri.XML xml
+        c14n = doc.at_xpath('//b').canonicalize
+        assert_equal '<b><c></c></b>', c14n
+      end
+
+      def test_c14n_modes
+        # http://www.w3.org/TR/xml-exc-c14n/#sec-Enveloping
+        
+        doc1 = Nokogiri.XML <<-EOXML
+<n0:local xmlns:n0="http://foobar.org" xmlns:n3="ftp://example.org">
+  <n1:elem2 xmlns:n1="http://example.net" xml:lang="en">
+    <n3:stuff xmlns:n3="ftp://example.org"/>
+  </n1:elem2>
+</n0:local>        
+        EOXML
+
+        doc2 = Nokogiri.XML <<-EOXML
+<n2:pdu xmlns:n1="http://example.com"
+           xmlns:n2="http://foo.example"
+           xmlns:n4="http://foo.example"
+           xml:lang="fr"
+           xml:space="retain">
+  <n1:elem2 xmlns:n1="http://example.net" xml:lang="en">
+    <n3:stuff xmlns:n3="ftp://example.org"/>
+    <n4:stuff />
+  </n1:elem2>
+</n2:pdu>        
+        EOXML
+
+        c14n = doc1.at_xpath('//n1:elem2', {'n1' => 'http://example.net'}).canonicalize
+        assert_equal '<n1:elem2 xmlns:n0="http://foobar.org" xmlns:n1="http://example.net" xmlns:n3="ftp://example.org" xml:lang="en">
+    <n3:stuff></n3:stuff>
+  </n1:elem2>', c14n
+
+        expected = '<n1:elem2 xmlns:n1="http://example.net" xmlns:n2="http://foo.example" xmlns:n4="http://foo.example" xml:lang="en" xml:space="retain">
+    <n3:stuff xmlns:n3="ftp://example.org"></n3:stuff>
+    <n4:stuff></n4:stuff>
+  </n1:elem2>'
+        c14n = doc2.at_xpath('//n1:elem2', {'n1' => 'http://example.net'}).canonicalize
+        assert_equal expected, c14n
+
+        expected = '<n1:elem2 xmlns:n1="http://example.net" xml:lang="en">
+    <n3:stuff xmlns:n3="ftp://example.org"></n3:stuff>
+  </n1:elem2>'
+        c14n = doc1.at_xpath('//n1:elem2', {'n1' => 'http://example.net'}).canonicalize(XML::XML_C14N_EXCLUSIVE_1_0)
+        assert_equal expected, c14n
+
+        expected = '<n1:elem2 xmlns:n1="http://example.net" xml:lang="en">
+    <n3:stuff xmlns:n3="ftp://example.org"></n3:stuff>
+    <n4:stuff xmlns:n4="http://foo.example"></n4:stuff>
+  </n1:elem2>'
+        c14n = doc2.at_xpath('//n1:elem2', {'n1' => 'http://example.net'}).canonicalize(XML::XML_C14N_EXCLUSIVE_1_0)
+        assert_equal expected, c14n
+
+        expected = '<n1:elem2 xmlns:n1="http://example.net" xmlns:n2="http://foo.example" xml:lang="en">
+    <n3:stuff xmlns:n3="ftp://example.org"></n3:stuff>
+    <n4:stuff xmlns:n4="http://foo.example"></n4:stuff>
+  </n1:elem2>'
+        c14n = doc2.at_xpath('//n1:elem2', {'n1' => 'http://example.net'}).canonicalize(XML::XML_C14N_EXCLUSIVE_1_0, ['n2'])
+        assert_equal expected, c14n
+
+        expected = '<n1:elem2 xmlns:n1="http://example.net" xmlns:n2="http://foo.example" xmlns:n4="http://foo.example" xml:lang="en">
+    <n3:stuff xmlns:n3="ftp://example.org"></n3:stuff>
+    <n4:stuff></n4:stuff>
+  </n1:elem2>'
+        c14n = doc2.at_xpath('//n1:elem2', {'n1' => 'http://example.net'}).canonicalize(XML::XML_C14N_EXCLUSIVE_1_0, ['n2', 'n4'])
+        assert_equal expected, c14n
+      end
+
+      def test_wrong_params
+        xml = '<a><b></b></a>'
+        doc = Nokogiri.XML xml
+
+        assert_raise(TypeError){ doc.canonicalize :wrong_type }
+        assert_raise(TypeError){ doc.canonicalize nil, :wrong_type }
+        doc.canonicalize nil, nil, :wrong_type
+      end
+
+
+    end
+  end
+end

data/vendor/cache/ruby/2.5.0/gems/nokogiri-1.8.2/test/xml/test_cdata.rb

@@ -0,0 +1,54 @@
+require "helper"
+
+module Nokogiri
+  module XML
+    class TestCDATA < Nokogiri::TestCase
+      def setup
+        super
+        @xml = Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE)
+      end
+
+      def test_cdata_node
+        name = @xml.xpath('//employee[2]/name').first
+        assert cdata = name.children[1]
+        assert cdata.cdata?
+        assert_equal '#cdata-section', cdata.name
+      end
+
+      def test_new
+        node = CDATA.new(@xml, "foo")
+        assert_equal "foo", node.content
+
+        node = CDATA.new(@xml.root, "foo")
+        assert_equal "foo", node.content
+      end
+
+      def test_new_with_nil
+        node = CDATA.new(@xml, nil)
+        assert_equal nil, node.content
+      end
+
+      def test_new_with_non_string
+        assert_raises(TypeError) do
+          CDATA.new(@xml, 1.234)
+        end
+      end
+
+      def test_lots_of_new_cdata
+        assert 100.times { CDATA.new(@xml, "asdfasdf") }
+      end
+
+      def test_content=
+        node = CDATA.new(@xml, 'foo')
+        assert_equal('foo', node.content)
+
+        node.content = '& <foo> &amp;'
+        assert_equal('& <foo> &amp;', node.content)
+        assert_equal('<![CDATA[& <foo> &amp;]]>', node.to_xml)
+
+        node.content = 'foo ]]> bar'
+        assert_equal('foo ]]> bar', node.content)
+      end
+    end
+  end
+end

data/vendor/cache/ruby/2.5.0/gems/nokogiri-1.8.2/test/xml/test_comment.rb

@@ -0,0 +1,40 @@
+require "helper"
+
+module Nokogiri
+  module XML
+    class TestComment < Nokogiri::TestCase
+      def setup
+        super
+        @xml = Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE)
+      end
+
+      def test_new
+        comment = Nokogiri::XML::Comment.new(@xml, 'hello world')
+        assert_equal('<!--hello world-->', comment.to_s)
+      end
+
+      def test_comment?
+        comment = Nokogiri::XML::Comment.new(@xml, 'hello world')
+        assert(comment.comment?)
+        assert(!@xml.root.comment?)
+      end
+
+      def test_passing_a_node_uses_the_node_document
+        comment = Nokogiri::XML::Comment.new(@xml.at_css("employee"), 'hello world')
+        assert_equal @xml, comment.document
+      end
+
+      def test_passing_anything_else
+        assert_raises ArgumentError do
+          Nokogiri::XML::Comment.new("NOT A NOKOGIRI CLASS", 'hello world')
+        end
+      end
+
+      def test_many_comments
+        100.times {
+          Nokogiri::XML::Comment.new(@xml, 'hello world')
+        }
+      end
+    end
+  end
+end

data/vendor/cache/ruby/2.5.0/gems/nokogiri-1.8.2/test/xml/test_document.rb

@@ -0,0 +1,982 @@
+require "helper"
+
+require 'uri'
+
+module Nokogiri
+  module XML
+    class TestDocument < Nokogiri::TestCase
+      URI = if URI.const_defined?(:DEFAULT_PARSER)
+              ::URI::DEFAULT_PARSER
+            else
+              ::URI
+            end
+
+      def setup
+        super
+        @xml = Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE)
+      end
+
+      def test_dtd_with_empty_internal_subset
+        doc = Nokogiri::XML <<-eoxml
+<?xml version="1.0"?>
+<!DOCTYPE people >
+<people>
+</people>
+        eoxml
+        assert doc.root
+      end
+
+      # issue #1005
+      def test_strict_parsing_empty_doc_should_raise_exception
+        ["", " "].each do |empty_string|
+          assert_raises(SyntaxError, "empty string '#{empty_string}' should raise a SyntaxError") do
+            Nokogiri::XML(empty_string) { |c| c.strict }
+          end
+          assert_raises(SyntaxError, "StringIO of '#{empty_string}' should raise a SyntaxError") do
+            Nokogiri::XML(StringIO.new(empty_string)) { |c| c.strict }
+          end
+        end
+      end
+
+      # issue #838
+      def test_document_with_invalid_prolog
+        doc = Nokogiri::XML '<? ?>'
+        assert_empty doc.content
+      end
+
+      # issue #837
+      def test_document_with_refentity
+        doc = Nokogiri::XML '&amp;'
+        assert_equal '', doc.content
+      end
+
+      # issue #835
+      def test_manually_adding_reference_entities
+        d = Nokogiri::XML::Document.new
+        root = Nokogiri::XML::Element.new('bar', d)
+        txt = Nokogiri::XML::Text.new('foo', d)
+        ent = Nokogiri::XML::EntityReference.new(d, '#8217')
+        root << txt
+        root << ent
+        d << root
+        assert_match(/&#8217;/, d.to_html)
+      end
+
+      def test_document_with_initial_space
+        doc = Nokogiri::XML(" <?xml version='1.0' encoding='utf-8' ?><first \>")
+        assert_equal 2, doc.children.size
+      end
+
+      def test_root_set_to_nil
+        @xml.root = nil
+        assert_equal nil, @xml.root
+      end
+
+      def test_million_laugh_attach
+        doc = Nokogiri::XML '<?xml version="1.0"?>
+<!DOCTYPE lolz [
+<!ENTITY lol "lol">
+<!ENTITY lol2 "&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;">
+<!ENTITY lol3 "&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;">
+<!ENTITY lol4 "&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;">
+<!ENTITY lol5 "&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;">
+<!ENTITY lol6 "&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;">
+<!ENTITY lol7 "&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;">
+<!ENTITY lol8 "&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;">
+<!ENTITY lol9 "&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;">
+]>
+<lolz>&lol9;</lolz>'
+        assert_not_nil doc
+      end
+
+      def test_million_laugh_attach_2
+        doc = Nokogiri::XML '<?xml version="1.0" encoding="UTF-8"?>
+ <!DOCTYPE member [
+   <!ENTITY a "&b;&b;&b;&b;&b;&b;&b;&b;&b;&b;">
+   <!ENTITY b "&c;&c;&c;&c;&c;&c;&c;&c;&c;&c;">
+   <!ENTITY c "&d;&d;&d;&d;&d;&d;&d;&d;&d;&d;">
+   <!ENTITY d "&e;&e;&e;&e;&e;&e;&e;&e;&e;&e;">
+   <!ENTITY e "&f;&f;&f;&f;&f;&f;&f;&f;&f;&f;">
+   <!ENTITY f "&g;&g;&g;&g;&g;&g;&g;&g;&g;&g;">
+   <!ENTITY g "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx">
+ ]>
+ <member>
+ &a;
+ </member>'
+        assert_not_nil doc
+      end
+
+      def test_ignore_unknown_namespace
+        doc = Nokogiri::XML(<<-eoxml)
+        <xml>
+          <unknown:foo xmlns='http://hello.com/' />
+          <bar />
+        </xml>
+        eoxml
+        if Nokogiri.jruby?
+          refute doc.xpath('//foo').first.namespace # assert that the namespace is nil
+        end
+        refute_empty doc.xpath('//bar'), "bar wasn't found in the document" # bar should be part of the doc
+      end
+
+      def test_collect_namespaces
+        doc = Nokogiri::XML(<<-eoxml)
+        <xml>
+          <foo xmlns='hello'>
+            <bar xmlns:foo='world' />
+          </foo>
+        </xml>
+        eoxml
+        assert_equal({"xmlns"=>"hello", "xmlns:foo"=>"world"},
+          doc.collect_namespaces)
+      end
+
+      def test_subclass_initialize_modify # testing a segv
+        Class.new(Nokogiri::XML::Document) {
+          def initialize
+            super
+            body_node = Nokogiri::XML::Node.new "body", self
+            body_node.content = "stuff"
+            self.root = body_node
+          end
+        }.new
+      end
+
+      def test_create_text_node
+        txt = @xml.create_text_node 'foo'
+        assert_instance_of Nokogiri::XML::Text, txt
+        assert_equal 'foo', txt.text
+        assert_equal @xml, txt.document
+      end
+
+      def test_create_text_node_with_block
+        @xml.create_text_node 'foo' do |txt|
+          assert_instance_of Nokogiri::XML::Text, txt
+          assert_equal 'foo', txt.text
+          assert_equal @xml, txt.document
+        end
+      end
+
+      def test_create_element
+        elm = @xml.create_element('foo')
+        assert_instance_of Nokogiri::XML::Element, elm
+        assert_equal 'foo', elm.name
+        assert_equal @xml, elm.document
+      end
+
+      def test_create_element_with_block
+        @xml.create_element('foo') do |elm|
+          assert_instance_of Nokogiri::XML::Element, elm
+          assert_equal 'foo', elm.name
+          assert_equal @xml, elm.document
+        end
+      end
+
+      def test_create_element_with_attributes
+        elm = @xml.create_element('foo',:a => "1")
+        assert_instance_of Nokogiri::XML::Element, elm
+        assert_instance_of Nokogiri::XML::Attr, elm.attributes["a"]
+        assert_equal "1", elm["a"]
+      end
+
+      def test_create_element_with_namespace
+        elm = @xml.create_element('foo',:'xmlns:foo' => 'http://tenderlovemaking.com')
+        assert_equal 'http://tenderlovemaking.com', elm.namespaces['xmlns:foo']
+      end
+
+      def test_create_element_with_hyphenated_namespace
+        elm = @xml.create_element('foo',:'xmlns:SOAP-ENC' => 'http://tenderlovemaking.com')
+        assert_equal 'http://tenderlovemaking.com', elm.namespaces['xmlns:SOAP-ENC']
+      end
+
+      def test_create_element_with_content
+        elm = @xml.create_element('foo',"needs more xml/violence")
+        assert_equal "needs more xml/violence", elm.content
+      end
+
+      def test_create_cdata
+        cdata = @xml.create_cdata("abc")
+        assert_instance_of Nokogiri::XML::CDATA, cdata
+        assert_equal "abc", cdata.content
+      end
+
+      def test_create_cdata_with_block
+        @xml.create_cdata("abc") do |cdata|
+          assert_instance_of Nokogiri::XML::CDATA, cdata
+          assert_equal "abc", cdata.content
+        end
+      end
+
+      def test_create_comment
+        comment = @xml.create_comment("abc")
+        assert_instance_of Nokogiri::XML::Comment, comment
+        assert_equal "abc", comment.content
+      end
+
+      def test_create_comment_with_block
+        @xml.create_comment("abc") do |comment|
+          assert_instance_of Nokogiri::XML::Comment, comment
+          assert_equal "abc", comment.content
+        end
+      end
+
+      def test_pp
+        out = StringIO.new(String.new)
+        ::PP.pp @xml, out
+        assert_operator out.string.length, :>, 0
+      end
+
+      def test_create_internal_subset_on_existing_subset
+        assert_not_nil @xml.internal_subset
+        assert_raises(RuntimeError) do
+          @xml.create_internal_subset('staff', nil, 'staff.dtd')
+        end
+      end
+
+      def test_create_internal_subset
+        xml = Nokogiri::XML('<root />')
+        assert_nil xml.internal_subset
+
+        xml.create_internal_subset('name', nil, 'staff.dtd')
+        ss = xml.internal_subset
+        assert_equal 'name', ss.name
+        assert_nil ss.external_id
+        assert_equal 'staff.dtd', ss.system_id
+      end
+
+      def test_external_subset
+        assert_nil @xml.external_subset
+        Dir.chdir(ASSETS_DIR) do
+          @xml = Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE) { |cfg|
+            cfg.dtdload
+          }
+        end
+        assert @xml.external_subset
+      end
+
+      def test_create_external_subset_fails_with_existing_subset
+        assert_nil @xml.external_subset
+        Dir.chdir(ASSETS_DIR) do
+          @xml = Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE) { |cfg|
+            cfg.dtdload
+          }
+        end
+        assert @xml.external_subset
+
+        assert_raises(RuntimeError) do
+          @xml.create_external_subset('staff', nil, 'staff.dtd')
+        end
+      end
+
+      def test_create_external_subset
+        dtd = @xml.create_external_subset('staff', nil, 'staff.dtd')
+        assert_nil dtd.external_id
+        assert_equal 'staff.dtd', dtd.system_id
+        assert_equal 'staff', dtd.name
+        assert_equal dtd, @xml.external_subset
+      end
+
+      def test_version
+        assert_equal '1.0', @xml.version
+      end
+
+      def test_add_namespace
+        assert_raise NoMethodError do
+          @xml.add_namespace('foo', 'bar')
+        end
+      end
+
+      def test_attributes
+        assert_raise NoMethodError do
+          @xml.attributes
+        end
+      end
+
+      def test_namespace
+        assert_raise NoMethodError do
+          @xml.namespace
+        end
+      end
+
+      def test_namespace_definitions
+        assert_raise NoMethodError do
+          @xml.namespace_definitions
+        end
+      end
+
+      def test_line
+        assert_raise NoMethodError do
+          @xml.line
+        end
+      end
+
+      def test_empty_node_converted_to_html_is_not_self_closing
+        doc = Nokogiri::XML('<a></a>')
+        assert_equal "<a></a>", doc.inner_html
+      end
+
+      def test_fragment
+        fragment = @xml.fragment
+        assert_equal 0, fragment.children.length
+      end
+
+      def test_add_child_fragment_with_single_node
+        doc = Nokogiri::XML::Document.new
+        fragment = doc.fragment('<hello />')
+        doc.add_child fragment
+        assert_equal '/hello', doc.at('//hello').path
+        assert_equal 'hello', doc.root.name
+      end
+
+      def test_add_child_fragment_with_multiple_nodes
+        doc = Nokogiri::XML::Document.new
+        fragment = doc.fragment('<hello /><goodbye />')
+        assert_raises(RuntimeError) do
+          doc.add_child fragment
+        end
+      end
+
+      def test_add_child_with_multiple_roots
+        assert_raises(RuntimeError) do
+          @xml << Node.new('foo', @xml)
+        end
+      end
+
+      def test_add_child_with_string
+        doc = Nokogiri::XML::Document.new
+        doc.add_child "<div>quack!</div>"
+        assert_equal 1, doc.root.children.length
+        assert_equal "quack!", doc.root.children.first.content
+      end
+
+      def test_prepend
+        doc = Nokogiri::XML('<root>')
+
+        node_set = doc.root.prepend_child '<branch/>'
+        assert_equal %w[branch], node_set.map(&:name)
+
+        branch = doc.at('//branch')
+
+        leaves = %w[leaf1 leaf2 leaf3]
+        leaves.each { |name|
+          branch.prepend_child('<%s/>' % name)
+        }
+        assert_equal leaves.length, branch.children.length
+        assert_equal leaves.reverse, branch.children.map(&:name)
+      end
+
+      def test_prepend_child_fragment_with_single_node
+        doc = Nokogiri::XML::Document.new
+        fragment = doc.fragment('<hello />')
+        doc.prepend_child fragment
+        assert_equal '/hello', doc.at('//hello').path
+        assert_equal 'hello', doc.root.name
+      end
+
+      def test_prepend_child_fragment_with_multiple_nodes
+        doc = Nokogiri::XML::Document.new
+        fragment = doc.fragment('<hello /><goodbye />')
+        assert_raises(RuntimeError) do
+          doc.prepend_child fragment
+        end
+      end
+
+      def test_prepend_child_with_multiple_roots
+        assert_raises(RuntimeError) do
+          @xml.prepend_child Node.new('foo', @xml)
+        end
+      end
+
+      def test_prepend_child_with_string
+        doc = Nokogiri::XML::Document.new
+        doc.prepend_child "<div>quack!</div>"
+        assert_equal 1, doc.root.children.length
+        assert_equal "quack!", doc.root.children.first.content
+      end
+
+      def test_move_root_to_document_with_no_root
+        sender = Nokogiri::XML('<root>foo</root>')
+        newdoc = Nokogiri::XML::Document.new
+        newdoc.root = sender.root
+      end
+
+      def test_move_root_with_existing_root_gets_gcd
+        doc = Nokogiri::XML('<root>test</root>')
+        doc2 = Nokogiri::XML("<root>#{'x' * 5000000}</root>")
+        doc2.root = doc.root
+      end
+
+      def test_validate
+        if Nokogiri.uses_libxml?
+          assert_equal 44, @xml.validate.length
+        else
+          xml = Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE) {|cfg| cfg.dtdvalid}
+          assert_equal 40, xml.validate.length
+        end
+      end
+
+      def test_validate_no_internal_subset
+        doc = Nokogiri::XML('<test/>')
+        assert_nil doc.validate
+      end
+
+      def test_clone
+        assert @xml.clone
+      end
+
+      def test_document_should_not_have_default_ns
+        doc = Nokogiri::XML::Document.new
+
+        assert_raises NoMethodError do
+          doc.default_namespace = 'http://innernet.com/'
+        end
+
+        assert_raises NoMethodError do
+          doc.add_namespace_definition('foo', 'bar')
+        end
+      end
+
+      def test_parse_handles_nil_gracefully
+        @doc = Nokogiri::XML::Document.parse(nil)
+        assert_instance_of Nokogiri::XML::Document, @doc
+      end
+
+      def test_parse_takes_block
+        options = nil
+        Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE) do |cfg|
+          options = cfg
+        end
+        assert options
+      end
+
+      def test_parse_yields_parse_options
+        options = nil
+        Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE) do |cfg|
+          options = cfg
+          options.nonet.nowarning.dtdattr
+        end
+        assert options.nonet?
+        assert options.nowarning?
+        assert options.dtdattr?
+      end
+
+      def test_XML_takes_block
+        options = nil
+        Nokogiri::XML(File.read(XML_FILE), XML_FILE) do |cfg|
+          options = cfg
+          options.nonet.nowarning.dtdattr
+        end
+        assert options.nonet?
+        assert options.nowarning?
+        assert options.dtdattr?
+      end
+
+      def test_subclass
+        klass = Class.new(Nokogiri::XML::Document)
+        doc = klass.new
+        assert_instance_of klass, doc
+      end
+
+      def test_subclass_initialize
+        klass = Class.new(Nokogiri::XML::Document) do
+          attr_accessor :initialized_with
+
+          def initialize(*args)
+            @initialized_with = args
+          end
+        end
+        doc = klass.new("1.0", 1)
+        assert_equal ["1.0", 1], doc.initialized_with
+      end
+
+      def test_subclass_dup
+        klass = Class.new(Nokogiri::XML::Document)
+        doc = klass.new.dup
+        assert_instance_of klass, doc
+      end
+
+      def test_subclass_parse
+        klass = Class.new(Nokogiri::XML::Document)
+        doc = klass.parse(File.read(XML_FILE))
+        # lame hack uses root to avoid comparing DOCTYPE tags which can appear out of order.
+        # I should really finish lorax and use that here.
+        assert_equal @xml.root.to_s, doc.root.to_s
+        assert_instance_of klass, doc
+      end
+
+      def test_document_parse_method
+        xml = Nokogiri::XML::Document.parse(File.read(XML_FILE))
+        # lame hack uses root to avoid comparing DOCTYPE tags which can appear out of order.
+        # I should really finish lorax and use that here.
+        assert_equal @xml.root.to_s, xml.root.to_s
+      end
+
+      def test_encoding=
+        @xml.encoding = 'UTF-8'
+        assert_match 'UTF-8', @xml.to_xml
+
+        @xml.encoding = 'EUC-JP'
+        assert_match 'EUC-JP', @xml.to_xml
+      end
+
+      def test_namespace_should_not_exist
+        assert_raises(NoMethodError) {
+          @xml.namespace
+        }
+      end
+
+      def test_non_existant_function
+        # WTF.  I don't know why this is different between MRI and Jruby
+        # They should be the same...  Either way, raising an exception
+        # is the correct thing to do.
+        exception = RuntimeError
+
+        if !Nokogiri.uses_libxml? || (Nokogiri.uses_libxml? && Nokogiri::VERSION_INFO['libxml']['platform'] == 'jruby')
+          exception = Nokogiri::XML::XPath::SyntaxError
+        end
+
+        assert_raises(exception) {
+          @xml.xpath('//name[foo()]')
+        }
+      end
+
+      def test_xpath_syntax_error
+        assert_raises(Nokogiri::XML::XPath::SyntaxError) do
+          @xml.xpath('\\')
+        end
+      end
+
+      def test_ancestors
+        assert_equal 0, @xml.ancestors.length
+      end
+
+      def test_root_node_parent_is_document
+        parent = @xml.root.parent
+        assert_equal @xml, parent
+        assert_instance_of Nokogiri::XML::Document, parent
+      end
+
+      def test_xmlns_is_automatically_registered
+        doc = Nokogiri::XML(<<-eoxml)
+          <root xmlns="http://tenderlovemaking.com/">
+            <foo>
+              bar
+            </foo>
+          </root>
+        eoxml
+        assert_equal 1, doc.css('xmlns|foo').length
+        assert_equal 1, doc.css('foo').length
+        assert_equal 0, doc.css('|foo').length
+        assert_equal 1, doc.xpath('//xmlns:foo').length
+        assert_equal 1, doc.search('xmlns|foo').length
+        assert_equal 1, doc.search('//xmlns:foo').length
+        assert doc.at('xmlns|foo')
+        assert doc.at('//xmlns:foo')
+        assert doc.at('foo')
+      end
+
+      def test_xmlns_is_registered_for_nodesets
+        doc = Nokogiri::XML(<<-eoxml)
+          <root xmlns="http://tenderlovemaking.com/">
+            <foo>
+              <bar>
+                baz
+              </bar>
+            </foo>
+          </root>
+        eoxml
+        assert_equal 1, doc.css('xmlns|foo').css('xmlns|bar').length
+        assert_equal 1, doc.css('foo').css('bar').length
+        assert_equal 1, doc.xpath('//xmlns:foo').xpath('./xmlns:bar').length
+        assert_equal 1, doc.search('xmlns|foo').search('xmlns|bar').length
+        assert_equal 1, doc.search('//xmlns:foo').search('./xmlns:bar').length
+      end
+
+      def test_to_xml_with_indent
+        doc = Nokogiri::XML('<root><foo><bar/></foo></root>')
+        doc = Nokogiri::XML(doc.to_xml(:indent => 5))
+
+        assert_indent 5, doc
+      end
+
+      def test_write_xml_to_with_indent
+        io = StringIO.new
+        doc = Nokogiri::XML('<root><foo><bar/></foo></root>')
+        doc.write_xml_to io, :indent => 5
+        io.rewind
+        doc = Nokogiri::XML(io.read)
+        assert_indent 5, doc
+      end
+
+      # wtf...  osx's libxml sucks.
+      unless !Nokogiri.uses_libxml? || Nokogiri::LIBXML_VERSION =~ /^2\.6\./
+        def test_encoding
+          xml = Nokogiri::XML(File.read(XML_FILE), XML_FILE, 'UTF-8')
+          assert_equal 'UTF-8', xml.encoding
+        end
+      end
+
+      def test_memory_explosion_on_invalid_xml
+        doc = Nokogiri::XML("<<<")
+        refute_nil doc
+        refute_empty doc.errors
+      end
+
+      def test_memory_explosion_on_wrong_formatted_element_following_the_root_element
+        doc = Nokogiri::XML("<a/><\n")
+        refute_nil doc
+        refute_empty doc.errors
+      end
+
+      def test_document_has_errors
+        doc = Nokogiri::XML(<<-eoxml)
+          <foo><bar></foo>
+        eoxml
+        assert doc.errors.length > 0
+        doc.errors.each do |error|
+          assert_match error.message, error.inspect
+          assert_match error.message, error.to_s
+        end
+      end
+
+      def test_strict_document_throws_syntax_error
+        assert_raises(Nokogiri::XML::SyntaxError) {
+          Nokogiri::XML('<foo><bar></foo>', nil, nil, 0)
+        }
+
+        assert_raises(Nokogiri::XML::SyntaxError) {
+          Nokogiri::XML('<foo><bar></foo>') { |cfg|
+            cfg.strict
+          }
+        }
+
+        assert_raises(Nokogiri::XML::SyntaxError) {
+          Nokogiri::XML(StringIO.new('<foo><bar></foo>')) { |cfg|
+            cfg.strict
+          }
+        }
+      end
+
+      def test_XML_function
+        xml = Nokogiri::XML(File.read(XML_FILE), XML_FILE)
+        assert xml.xml?
+      end
+
+      def test_url
+        assert @xml.url
+        assert_equal XML_FILE, URI.unescape(@xml.url).sub('file:///', '')
+      end
+
+      def test_document_parent
+        xml = Nokogiri::XML(File.read(XML_FILE), XML_FILE)
+        assert_raises(NoMethodError) {
+          xml.parent
+        }
+      end
+
+      def test_document_name
+        xml = Nokogiri::XML(File.read(XML_FILE), XML_FILE)
+        assert_equal 'document', xml.name
+      end
+
+      def test_parse_can_take_io
+        xml = nil
+        File.open(XML_FILE, 'rb') { |f|
+          xml = Nokogiri::XML(f)
+        }
+        assert xml.xml?
+        set = xml.search('//employee')
+        assert set.length > 0
+      end
+
+      def test_parsing_empty_io
+        doc = Nokogiri::XML.parse(StringIO.new(''))
+        refute_nil doc
+      end
+
+      def test_parse_works_with_an_object_that_responds_to_read
+        klass = Class.new do
+          def read *args
+            "<div>foo</div>"
+          end
+        end
+
+        doc = Nokogiri::XML.parse klass.new
+        doc.at_css("div").content.must_equal("foo")
+      end
+
+      def test_search_on_empty_documents
+        doc = Nokogiri::XML::Document.new
+        ns = doc.search('//foo')
+        assert_equal 0, ns.length
+
+        ns = doc.css('foo')
+        assert_equal 0, ns.length
+
+        ns = doc.xpath('//foo')
+        assert_equal 0, ns.length
+      end
+
+      def test_document_search_with_multiple_queries
+        xml = '<document>
+                 <thing>
+                   <div class="title">important thing</div>
+                 </thing>
+                 <thing>
+                   <div class="content">stuff</div>
+                 </thing>
+                 <thing>
+                   <p class="blah">more stuff</div>
+                 </thing>
+               </document>'
+        document = Nokogiri::XML(xml)
+        assert_kind_of Nokogiri::XML::Document, document
+
+        assert_equal 3, document.xpath('.//div', './/p').length
+        assert_equal 3, document.css('.title', '.content', 'p').length
+        assert_equal 3, document.search('.//div', 'p.blah').length
+      end
+
+      def test_bad_xpath_raises_syntax_error
+        assert_raises(XML::XPath::SyntaxError) {
+          @xml.xpath('\\')
+        }
+      end
+
+      def test_find_with_namespace
+        doc = Nokogiri::XML.parse(<<-eoxml)
+        <x xmlns:tenderlove='http://tenderlovemaking.com/'>
+          <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
+        </x>
+        eoxml
+
+        ctx = Nokogiri::XML::XPathContext.new(doc)
+        ctx.register_ns 'tenderlove', 'http://tenderlovemaking.com/'
+        set = ctx.evaluate('//tenderlove:foo')
+        assert_equal 1, set.length
+        assert_equal 'foo', set.first.name
+
+        # It looks like only the URI is important:
+        ctx = Nokogiri::XML::XPathContext.new(doc)
+        ctx.register_ns 'america', 'http://tenderlovemaking.com/'
+        set = ctx.evaluate('//america:foo')
+        assert_equal 1, set.length
+        assert_equal 'foo', set.first.name
+
+        # Its so important that a missing slash will cause it to return nothing
+        ctx = Nokogiri::XML::XPathContext.new(doc)
+        ctx.register_ns 'america', 'http://tenderlovemaking.com'
+        set = ctx.evaluate('//america:foo')
+        assert_equal 0, set.length
+      end
+
+      def test_xml?
+        assert @xml.xml?
+      end
+
+      def test_document
+        assert @xml.document
+      end
+
+      def test_singleton_methods
+        assert node_set = @xml.search('//name')
+        assert node_set.length > 0
+        node = node_set.first
+        def node.test
+          'test'
+        end
+        assert node_set = @xml.search('//name')
+        assert_equal 'test', node_set.first.test
+      end
+
+      def test_multiple_search
+        assert node_set = @xml.search('//employee', '//name')
+        employees = @xml.search('//employee')
+        names = @xml.search('//name')
+        assert_equal(employees.length + names.length, node_set.length)
+      end
+
+      def test_node_set_index
+        assert node_set = @xml.search('//employee')
+
+        assert_equal(5, node_set.length)
+        assert node_set[4]
+        assert_nil node_set[5]
+      end
+
+      def test_search
+        assert node_set = @xml.search('//employee')
+
+        assert_equal(5, node_set.length)
+
+        node_set.each do |node|
+          assert_equal('employee', node.name)
+        end
+      end
+
+      def test_dump
+        assert @xml.serialize
+        assert @xml.to_xml
+      end
+
+      def test_dup
+        dup = @xml.dup
+        assert_instance_of Nokogiri::XML::Document, dup
+        assert dup.xml?, 'duplicate should be xml'
+      end
+
+      def test_new
+        doc = nil
+        doc = Nokogiri::XML::Document.new
+        assert doc
+        assert doc.xml?
+        assert_nil doc.root
+      end
+
+      def test_set_root
+        doc = nil
+        doc = Nokogiri::XML::Document.new
+        assert doc
+        assert doc.xml?
+        assert_nil doc.root
+        node = Nokogiri::XML::Node.new("b", doc) { |n|
+          n.content = 'hello world'
+        }
+        assert_equal('hello world', node.content)
+        doc.root = node
+        assert_equal(node, doc.root)
+      end
+
+      def test_remove_namespaces
+        doc = Nokogiri::XML <<-EOX
+          <root xmlns:a="http://a.flavorjon.es/" xmlns:b="http://b.flavorjon.es/">
+            <a:foo>hello from a</a:foo>
+            <b:foo>hello from b</b:foo>
+            <container xmlns:c="http://c.flavorjon.es/">
+              <c:foo c:attr='attr-value'>hello from c</c:foo>
+            </container>
+          </root>
+        EOX
+
+        namespaces = doc.root.namespaces
+
+        # assert on setup
+        assert_equal 2, doc.root.namespaces.length
+        assert_equal 3, doc.at_xpath("//container").namespaces.length
+        assert_equal 0, doc.xpath("//foo").length
+        assert_equal 1, doc.xpath("//a:foo").length
+        assert_equal 1, doc.xpath("//a:foo").length
+        assert_equal 1, doc.xpath("//x:foo", "x" => "http://c.flavorjon.es/").length
+        assert_match %r{foo c:attr}, doc.to_xml
+        doc.at_xpath("//x:foo", "x" => "http://c.flavorjon.es/").tap do |node|
+          assert_equal nil,          node["attr"]
+          assert_equal "attr-value", node["c:attr"]
+          assert_equal nil,          node.attribute_with_ns("attr", nil)
+          assert_equal "attr-value", node.attribute_with_ns("attr", "http://c.flavorjon.es/").value
+          assert_equal "attr-value", node.attributes["attr"].value
+        end
+
+        doc.remove_namespaces!
+
+        assert_equal 0, doc.root.namespaces.length
+        assert_equal 0, doc.at_xpath("//container").namespaces.length
+        assert_equal 3, doc.xpath("//foo").length
+        assert_equal 0, doc.xpath("//a:foo", namespaces).length
+        assert_equal 0, doc.xpath("//a:foo", namespaces).length
+        assert_equal 0, doc.xpath("//x:foo", "x" => "http://c.flavorjon.es/").length
+        assert_match %r{foo attr}, doc.to_xml
+        doc.at_xpath("//container/foo").tap do |node|
+          assert_equal "attr-value", node["attr"]
+          assert_equal nil,          node["c:attr"]
+          assert_equal "attr-value", node.attribute_with_ns("attr", nil).value
+          assert_equal nil,          node.attribute_with_ns("attr", "http://c.flavorjon.es/")
+          assert_equal "attr-value", node.attributes["attr"].value # doesn't change!
+        end
+      end
+
+      # issue #785
+      def test_attribute_decoration
+        decorator = Module.new do
+          def test_method
+          end
+        end
+
+        util_decorate(@xml, decorator)
+
+        assert @xml.search('//@street').first.respond_to?(:test_method)
+      end
+
+      def test_subset_is_decorated
+        x = Module.new do
+          def awesome!
+          end
+        end
+        util_decorate(@xml, x)
+
+        assert @xml.respond_to?(:awesome!)
+        assert node_set = @xml.search('//staff')
+        assert node_set.respond_to?(:awesome!)
+        assert subset = node_set.search('.//employee')
+        assert subset.respond_to?(:awesome!)
+        assert sub_subset = node_set.search('.//name')
+        assert sub_subset.respond_to?(:awesome!)
+      end
+
+      def test_decorator_is_applied
+        x = Module.new do
+          def awesome!
+          end
+        end
+        util_decorate(@xml, x)
+
+        assert @xml.respond_to?(:awesome!)
+        assert node_set = @xml.search('//employee')
+        assert node_set.respond_to?(:awesome!)
+        node_set.each do |node|
+          assert node.respond_to?(:awesome!), node.class
+        end
+        assert @xml.root.respond_to?(:awesome!)
+        assert @xml.children.respond_to?(:awesome!)
+      end
+
+      if Nokogiri.jruby?
+        def wrap_java_document
+          require 'java'
+          factory = javax.xml.parsers.DocumentBuilderFactory.newInstance
+          builder = factory.newDocumentBuilder
+          document = builder.newDocument
+          root = document.createElement("foo")
+          document.appendChild(root)
+          Nokogiri::XML::Document.wrap(document)
+        end
+      end
+
+      def test_java_integration
+        skip("Ruby doesn't have the wrap method") unless Nokogiri.jruby?
+        noko_doc = wrap_java_document
+        assert_equal 'foo', noko_doc.root.name
+
+        noko_doc = Nokogiri::XML(<<eoxml)
+<foo xmlns='hello'>
+  <bar xmlns:foo='world' />
+</foo>
+eoxml
+        dom = noko_doc.to_java
+        assert dom.kind_of? org.w3c.dom.Document
+        assert_equal 'foo', dom.getDocumentElement().getTagName()
+      end
+
+      def test_add_child
+        skip("Ruby doesn't have the wrap method") unless Nokogiri.jruby?
+        doc = wrap_java_document
+        doc.root.add_child "<bar />"
+      end
+
+      def test_can_be_closed
+        f = File.open XML_FILE
+        Nokogiri::XML f
+        f.close
+      end
+    end
+  end
+end