nokogiri 1.9.0.rc1 → 1.9.0

data/test/xml/test_reader_encoding.rb

@@ -1,134 +0,0 @@
-# -*- coding: utf-8 -*-
-require "helper"
-
-module Nokogiri
-  module XML
-    class TestReaderEncoding < Nokogiri::TestCase
-      def setup
-        super
-        @reader = Nokogiri::XML::Reader(
-          File.read(XML_FILE),
-          XML_FILE,
-          'UTF-8'
-        )
-      end
-
-      def test_attribute_at
-        @reader.each do |node|
-          next unless attribute = node.attribute_at(0)
-          assert_equal @reader.encoding, attribute.encoding.name
-        end
-      end
-
-      def test_attributes
-        @reader.each do |node|
-          node.attributes.each do |k,v|
-            assert_equal @reader.encoding, k.encoding.name
-            assert_equal @reader.encoding, v.encoding.name
-          end
-        end
-      end
-
-      def test_attribute
-        xml = <<-eoxml
-          <x xmlns:tenderlove='http://tenderlovemaking.com/'>
-            <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
-          </x>
-        eoxml
-        reader = Nokogiri::XML::Reader(xml, nil, 'UTF-8')
-        reader.each do |node|
-          next unless attribute = node.attribute('awesome')
-          assert_equal reader.encoding, attribute.encoding.name
-        end
-      end
-
-      def test_xml_version
-        @reader.each do |node|
-          next unless version = node.xml_version
-          assert_equal @reader.encoding, version.encoding.name
-        end
-      end
-
-      def test_lang
-        xml = <<-eoxml
-          <awesome>
-            <p xml:lang="en">The quick brown fox jumps over the lazy dog.</p>
-            <p xml:lang="ja">日本語が上手です</p>
-          </awesome>
-        eoxml
-
-        reader = Nokogiri::XML::Reader(xml, nil, 'UTF-8')
-        reader.each do |node|
-          next unless lang = node.lang
-          assert_equal reader.encoding, lang.encoding.name
-        end
-      end
-
-      def test_value
-        called = false
-        @reader.each do |node|
-          next unless value = node.value
-          assert_equal @reader.encoding, value.encoding.name
-          called = true
-        end
-        assert called
-      end
-
-      def test_prefix
-        xml = <<-eoxml
-          <x xmlns:edi='http://ecommerce.example.org/schema'>
-            <edi:foo>hello</edi:foo>
-          </x>
-        eoxml
-        reader = Nokogiri::XML::Reader(xml, nil, 'UTF-8')
-        reader.each do |node|
-          next unless prefix = node.prefix
-          assert_equal reader.encoding, prefix.encoding.name
-        end
-      end
-
-      def test_ns_uri
-        xml = <<-eoxml
-          <x xmlns:edi='http://ecommerce.example.org/schema'>
-            <edi:foo>hello</edi:foo>
-          </x>
-        eoxml
-        reader = Nokogiri::XML::Reader(xml, nil, 'UTF-8')
-        reader.each do |node|
-          next unless uri = node.namespace_uri
-          assert_equal reader.encoding, uri.encoding.name
-        end
-      end
-
-      def test_local_name
-        xml = <<-eoxml
-          <x xmlns:edi='http://ecommerce.example.org/schema'>
-            <edi:foo>hello</edi:foo>
-          </x>
-        eoxml
-        reader = Nokogiri::XML::Reader(xml, nil, 'UTF-8')
-        reader.each do |node|
-          next unless lname = node.local_name
-          assert_equal reader.encoding, lname.encoding.name
-        end
-      end
-
-      def test_name
-        @reader.each do |node|
-          next unless name = node.name
-          assert_equal @reader.encoding, name.encoding.name
-        end
-      end
-
-      def test_value_lookup_segfault
-        skip("JRuby doesn't do GC.") if Nokogiri.jruby?
-        stress_memory_while do
-          while node = @reader.read
-            nodes = node.send(:attr_nodes)
-            nodes.first.name if nodes.first
-          end
-        end
-      end
-    end
-  end
-end

data/test/xml/test_relax_ng.rb

@@ -1,60 +0,0 @@
-require "helper"
-
-module Nokogiri
-  module XML
-    class TestRelaxNG < Nokogiri::TestCase
-      def setup
-        assert @schema = Nokogiri::XML::RelaxNG(File.read(ADDRESS_SCHEMA_FILE))
-      end
-
-      def test_parse_with_memory
-        assert_instance_of Nokogiri::XML::RelaxNG, @schema
-        assert_equal 0, @schema.errors.length
-      end
-
-      def test_new
-        assert schema = Nokogiri::XML::RelaxNG.new(
-          File.read(ADDRESS_SCHEMA_FILE))
-        assert_instance_of Nokogiri::XML::RelaxNG, schema
-      end
-
-      def test_parse_with_io
-        xsd = nil
-        File.open(ADDRESS_SCHEMA_FILE, 'rb') { |f|
-          assert xsd = Nokogiri::XML::RelaxNG(f)
-        }
-        assert_equal 0, xsd.errors.length
-      end
-
-      def test_parse_with_errors
-        xml = File.read(ADDRESS_SCHEMA_FILE).sub(/name="/, 'name=')
-        assert_raises(Nokogiri::XML::SyntaxError) {
-          Nokogiri::XML::RelaxNG(xml)
-        }
-      end
-
-      def test_validate_document
-        doc = Nokogiri::XML(File.read(ADDRESS_XML_FILE))
-        assert errors = @schema.validate(doc)
-        assert_equal 0, errors.length
-      end
-
-      def test_validate_invalid_document
-        # Empty address book is not allowed
-        read_doc = '<addressBook></addressBook>'
-
-        assert errors = @schema.validate(Nokogiri::XML(read_doc))
-        assert_equal 1, errors.length
-      end
-
-      def test_valid?
-        valid_doc = Nokogiri::XML(File.read(ADDRESS_XML_FILE))
-
-        invalid_doc = Nokogiri::XML('<addressBook></addressBook>')
-
-        assert(@schema.valid?(valid_doc))
-        assert(!@schema.valid?(invalid_doc))
-      end
-    end
-  end
-end

data/test/xml/test_schema.rb

@@ -1,142 +0,0 @@
-require "helper"
-
-module Nokogiri
-  module XML
-    class TestSchema < Nokogiri::TestCase
-      def setup
-        assert @xsd = Nokogiri::XML::Schema(File.read(PO_SCHEMA_FILE))
-      end
-
-      def test_schema_from_document
-        doc = Nokogiri::XML(File.open(PO_SCHEMA_FILE))
-        assert doc
-        xsd = Nokogiri::XML::Schema.from_document doc
-        assert_instance_of Nokogiri::XML::Schema, xsd
-      end
-
-      def test_invalid_schema_do_not_raise_exceptions
-        xsd = Nokogiri::XML::Schema.new <<EOF
-<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
-	<xs:group name="foo1">
-		<xs:sequence>
-			<xs:element name="bar" type="xs:boolean" />
-		</xs:sequence>
-  </xs:group>
-	<xs:group name="foo2">
-		<xs:sequence>
-			<xs:element name="bar" type="xs:string" />
-		</xs:sequence>
-  </xs:group>
-	<xs:element name="foo">
-		<xs:complexType>
-			<xs:choice>
-				<xs:group ref="foo1"/>
-				<xs:group ref="foo2"/>
-			</xs:choice>
-		</xs:complexType>
-	</xs:element>
-</xs:schema>
-EOF
-        assert_instance_of Nokogiri::XML::Schema, xsd
-      end
-
-      def test_schema_from_document_node
-        doc = Nokogiri::XML(File.open(PO_SCHEMA_FILE))
-        assert doc
-        xsd = Nokogiri::XML::Schema.from_document doc.root
-        assert_instance_of Nokogiri::XML::Schema, xsd
-      end
-
-      def test_schema_validates_with_relative_paths
-        xsd = File.join(ASSETS_DIR, 'foo', 'foo.xsd')
-        xml = File.join(ASSETS_DIR, 'valid_bar.xml')
-        doc = Nokogiri::XML(File.open(xsd))
-        xsd = Nokogiri::XML::Schema.from_document doc
-
-        doc = Nokogiri::XML(File.open(xml))
-        assert xsd.valid?(doc)
-      end
-
-      def test_parse_with_memory
-        assert_instance_of Nokogiri::XML::Schema, @xsd
-        assert_equal 0, @xsd.errors.length
-      end
-
-      def test_new
-        assert xsd = Nokogiri::XML::Schema.new(File.read(PO_SCHEMA_FILE))
-        assert_instance_of Nokogiri::XML::Schema, xsd
-      end
-
-      def test_parse_with_io
-        xsd = nil
-        File.open(PO_SCHEMA_FILE, 'rb') { |f|
-          assert xsd = Nokogiri::XML::Schema(f)
-        }
-        assert_equal 0, xsd.errors.length
-      end
-
-      def test_parse_with_errors
-        xml = File.read(PO_SCHEMA_FILE).sub(/name="/, 'name=')
-        assert_raises(Nokogiri::XML::SyntaxError) {
-          Nokogiri::XML::Schema(xml)
-        }
-      end
-
-      def test_validate_document
-        doc = Nokogiri::XML(File.read(PO_XML_FILE))
-        assert errors = @xsd.validate(doc)
-        assert_equal 0, errors.length
-      end
-
-      def test_validate_file
-        assert errors = @xsd.validate(PO_XML_FILE)
-        assert_equal 0, errors.length
-      end
-
-      def test_validate_invalid_document
-        doc = Nokogiri::XML File.read(PO_XML_FILE)
-        doc.css("city").unlink
-
-        assert errors = @xsd.validate(doc)
-        assert_equal 2, errors.length
-      end
-
-      def test_validate_invalid_file
-        tempfile = Tempfile.new("xml")
-
-        doc = Nokogiri::XML File.read(PO_XML_FILE)
-        doc.css("city").unlink
-        tempfile.write doc.to_xml
-        tempfile.close
-
-        assert errors = @xsd.validate(tempfile.path)
-        assert_equal 2, errors.length
-      end
-
-      def test_validate_non_document
-        string = File.read(PO_XML_FILE)
-        assert_raise(ArgumentError) {@xsd.validate(string)}
-      end
-
-      def test_valid?
-        valid_doc = Nokogiri::XML(File.read(PO_XML_FILE))
-
-        invalid_doc = Nokogiri::XML(
-          File.read(PO_XML_FILE).gsub(/<city>[^<]*<\/city>/, '')
-        )
-
-        assert(@xsd.valid?(valid_doc))
-        assert(!@xsd.valid?(invalid_doc))
-      end
-
-      def test_xsd_with_dtd
-        Dir.chdir(File.join(ASSETS_DIR, 'saml')) do
-           # works
-           Nokogiri::XML::Schema(IO.read('xmldsig_schema.xsd'))
-           # was not working
-           Nokogiri::XML::Schema(IO.read('saml20protocol_schema.xsd'))
-        end
-      end
-    end
-  end
-end

data/test/xml/test_syntax_error.rb

@@ -1,36 +0,0 @@
-require "helper"
-
-module Nokogiri
-  module XML
-    class TestSyntaxError < Nokogiri::TestCase
-      def test_new
-        error = Nokogiri::XML::SyntaxError.new 'hello'
-        assert_equal 'hello', error.message
-      end
-
-      def test_line_column_level_libxml
-        skip unless Nokogiri.uses_libxml?
-
-        bad_doc = Nokogiri::XML('test')
-        error = bad_doc.errors.first
-
-        assert_equal "1:1: FATAL: Start tag expected, '<' not found", error.message
-        assert_equal 1, error.line
-        assert_equal 1, error.column
-        assert_equal 3, error.level
-      end
-
-      def test_line_column_level_jruby
-        skip unless Nokogiri.jruby?
-
-        bad_doc = Nokogiri::XML('<root>test</bar>')
-        error = bad_doc.errors.first
-
-        assert_equal "The element type \"root\" must be terminated by the matching end-tag \"</root>\".", error.message
-        assert_nil error.line
-        assert_nil error.column
-        assert_nil error.level
-      end
-    end
-  end
-end

data/test/xml/test_text.rb

@@ -1,69 +0,0 @@
-require "helper"
-
-module Nokogiri
-  module XML
-    class TestText < Nokogiri::TestCase
-      def test_css_path
-        doc  = Nokogiri.XML "<root> foo <a>something</a> bar bazz </root>"
-        node = doc.root.children[2]
-        assert_instance_of Nokogiri::XML::Text, node
-        assert_equal node, doc.at_css(node.css_path)
-      end
-
-      def test_inspect
-        node = Text.new('hello world', Document.new)
-        assert_equal "#<#{node.class.name}:#{sprintf("0x%x",node.object_id)} #{node.text.inspect}>", node.inspect
-      end
-
-      def test_new
-        node = Text.new('hello world', Document.new)
-        assert node
-        assert_equal('hello world', node.content)
-        assert_instance_of Nokogiri::XML::Text, node
-      end
-
-      def test_lots_of_text
-        100.times { Text.new('hello world', Document.new) }
-      end
-
-      def test_new_without_document
-        doc = Document.new
-        node = Nokogiri::XML::Element.new('foo', doc)
-
-        assert Text.new('hello world', node)
-      end
-
-      def test_content=
-        node = Text.new('foo', Document.new)
-        assert_equal('foo', node.content)
-        node.content = '& <foo> &amp;'
-        assert_equal('& <foo> &amp;', node.content)
-        assert_equal('&amp; &lt;foo&gt; &amp;amp;', node.to_xml)
-      end
-
-      def test_add_child
-        node = Text.new('foo', Document.new)
-        if Nokogiri.jruby?
-          exc = RuntimeError
-        else
-          exc = ArgumentError
-        end
-        assert_raises(exc) {
-          node.add_child Text.new('bar', Document.new)
-        }
-        assert_raises(exc) {
-          node << Text.new('bar', Document.new)
-        }
-      end
-
-      def test_wrap
-        xml = '<root><thing><div class="title">important thing</div></thing></root>'
-        doc = Nokogiri::XML(xml)
-        text = doc.at_css("div").children.first
-        text.wrap("<wrapper/>")
-        assert_equal 'wrapper', text.parent.name
-        assert_equal 'wrapper', doc.at_css("div").children.first.name
-      end
-    end
-  end
-end

data/test/xml/test_unparented_node.rb

@@ -1,483 +0,0 @@
-require "helper"
-
-require 'stringio'
-
-module Nokogiri
-  module XML
-    class TestUnparentedNode < Nokogiri::TestCase
-      def setup
-        begin
-          xml = Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE)
-          @node = xml.at('staff')
-          @node.unlink
-        end
-        GC.start # try to GC the document
-      end
-
-      def test_node_still_has_document
-        assert @node.document
-      end
-
-      def test_add_namespace
-        node = @node.at('address')
-        node.unlink
-        node.add_namespace('foo', 'http://tenderlovemaking.com')
-        assert_equal 'http://tenderlovemaking.com', node.namespaces['xmlns:foo']
-      end
-
-      def test_write_to
-        io = StringIO.new
-        @node.write_to io
-        io.rewind
-        assert_equal @node.to_xml, io.read
-      end
-
-      def test_attribute_with_symbol
-        assert_equal 'Yes', @node.css('address').first[:domestic]
-      end
-
-      def test_write_to_with_block
-        called = false
-        io = StringIO.new
-        conf = nil
-        @node.write_to io do |config|
-          called = true
-          conf = config
-          config.format.as_html.no_empty_tags
-        end
-        io.rewind
-        assert called
-        assert_equal @node.serialize(:save_with => conf.options), io.read
-      end
-
-      %w{ xml html xhtml }.each do |type|
-        define_method(:"test_write_#{type}_to") do
-          io = StringIO.new
-          assert @node.send(:"write_#{type}_to", io)
-          io.rewind
-          assert_match @node.send(:"to_#{type}"), io.read
-        end
-      end
-
-      def test_serialize_with_block
-        called = false
-        conf = nil
-        string = @node.serialize do |config|
-          called = true
-          conf = config
-          config.format.as_html.no_empty_tags
-        end
-        assert called
-        assert_equal @node.serialize(nil, conf.options), string
-      end
-
-      def test_values
-        assert_equal %w{ Yes Yes }, @node.xpath('.//address')[1].values
-      end
-
-      def test_keys
-        assert_equal %w{ domestic street }, @node.xpath('.//address')[1].keys
-      end
-
-      def test_each
-        attributes = []
-        @node.xpath('.//address')[1].each do |key, value|
-          attributes << [key, value]
-        end
-        assert_equal [['domestic', 'Yes'], ['street', 'Yes']], attributes
-      end
-
-      def test_new
-        assert node = Nokogiri::XML::Node.new('input', @node)
-        assert_equal 1, node.node_type
-      end
-
-      def test_to_str
-        assert name = @node.xpath('.//name').first
-        assert_match(/Margaret/, '' + name)
-        assert_equal('Margaret Martin', '' + name.children.first)
-      end
-
-      def test_ancestors
-        assert(address = @node.xpath('.//address').first)
-        assert_equal 2, address.ancestors.length
-        assert_equal ['employee', 'staff'],
-          address.ancestors.map { |x| x ? x.name : x }
-      end
-
-      def test_read_only?
-        assert entity_decl = @node.internal_subset.children.find { |x|
-          x.type == Node::ENTITY_DECL
-        }
-        assert entity_decl.read_only?
-      end
-
-      def test_remove_attribute
-        address = @node.xpath('./employee/address').first
-        assert_equal 'Yes', address['domestic']
-        address.remove_attribute 'domestic'
-        assert_nil address['domestic']
-      end
-
-      def test_delete
-        address = @node.xpath('./employee/address').first
-        assert_equal 'Yes', address['domestic']
-        address.delete 'domestic'
-        assert_nil address['domestic']
-      end
-
-      def test_add_child_in_same_document
-        child = @node.css('employee').first
-
-        assert child.children.last
-        assert new_child = child.children.first
-
-        last = child.children.last
-
-        child.add_child(new_child)
-        assert_equal new_child, child.children.last
-        assert_equal last, child.children.last
-      end
-
-      def test_add_child_from_other_document
-        d1 = Nokogiri::XML("<root><item>1</item><item>2</item></root>")
-        d2 = Nokogiri::XML("<root><item>3</item><item>4</item></root>")
-
-        d2.at('root').search('item').each do |i|
-          d1.at('root').add_child i
-        end
-
-        assert_equal 0, d2.search('item').size
-        assert_equal 4, d1.search('item').size
-      end
-
-      def test_add_child
-        xml = Nokogiri::XML(<<-eoxml)
-        <root>
-          <a>Hello world</a>
-        </root>
-        eoxml
-        text_node = Nokogiri::XML::Text.new('hello', xml)
-        assert_equal Nokogiri::XML::Node::TEXT_NODE, text_node.type
-        xml.root.add_child text_node
-        assert_match 'hello', xml.to_s
-      end
-
-      def test_chevron_works_as_add_child
-        xml = Nokogiri::XML(<<-eoxml)
-        <root>
-          <a>Hello world</a>
-        </root>
-        eoxml
-        text_node = Nokogiri::XML::Text.new('hello', xml)
-        xml.root << text_node
-        assert_match 'hello', xml.to_s
-      end
-
-      def test_add_previous_sibling
-        xml = Nokogiri::XML(<<-eoxml)
-        <root>
-          <a>Hello world</a>
-        </root>
-        eoxml
-        b_node = Nokogiri::XML::Node.new('a', xml)
-        assert_equal Nokogiri::XML::Node::ELEMENT_NODE, b_node.type
-        b_node.content = 'first'
-        a_node = xml.xpath('.//a').first
-        a_node.add_previous_sibling(b_node)
-        assert_equal('first', xml.xpath('.//a').first.text)
-      end
-
-      def test_add_previous_sibling_merge
-        xml = Nokogiri::XML(<<-eoxml)
-        <root>
-          <a>Hello world</a>
-        </root>
-        eoxml
-
-        assert a_tag = xml.css('a').first
-
-        left_space = a_tag.previous
-        right_space = a_tag.next
-        assert left_space.text?
-        assert right_space.text?
-
-        left_space.add_previous_sibling(right_space)
-        assert_equal left_space, right_space
-      end
-
-      def test_add_next_sibling_merge
-        xml = Nokogiri::XML(<<-eoxml)
-        <root>
-          <a>Hello world</a>
-        </root>
-        eoxml
-
-        assert a_tag = xml.css('a').first
-
-        left_space = a_tag.previous
-        right_space = a_tag.next
-        assert left_space.text?
-        assert right_space.text?
-
-        right_space.add_next_sibling(left_space)
-        assert_equal left_space, right_space
-      end
-
-      def test_add_next_sibling_to_root_raises_exception
-        xml = Nokogiri::XML(<<-eoxml)
-        <root />
-        eoxml
-
-        node = Nokogiri::XML::Node.new 'child', xml
-
-        assert_raise(ArgumentError) do
-          xml.root.add_next_sibling(node)
-        end
-      end
-
-      def test_add_previous_sibling_to_root_raises_exception
-        xml = Nokogiri::XML(<<-eoxml)
-        <root />
-        eoxml
-
-        node = Nokogiri::XML::Node.new 'child', xml
-
-        assert_raise(ArgumentError) do
-          xml.root.add_previous_sibling(node)
-        end
-      end
-
-      def test_document_root_can_have_a_comment_sibling_via_add_child
-        doc = Nokogiri::XML "<root>foo</root>"
-        comment = Nokogiri::XML::Comment.new(doc, "this is a comment")
-        doc.add_child comment
-        assert_equal [doc.root, comment], doc.children.to_a
-      end
-
-      def test_document_root_can_have_a_comment_sibling_via_prepend_child
-        doc = Nokogiri::XML "<root>foo</root>"
-        comment = Nokogiri::XML::Comment.new(doc, "this is a comment")
-        doc.prepend_child comment
-        assert_equal [comment, doc.root], doc.children.to_a
-      end
-
-      def test_document_root_can_have_a_comment_sibling_via_add_next_sibling
-        doc = Nokogiri::XML "<root>foo</root>"
-        comment = Nokogiri::XML::Comment.new(doc, "this is a comment")
-        doc.root.add_next_sibling comment
-        assert_equal [doc.root, comment], doc.children.to_a
-      end
-
-      def test_document_root_can_have_a_comment_sibling_via_add_previous_sibling
-        doc = Nokogiri::XML "<root>foo</root>"
-        comment = Nokogiri::XML::Comment.new(doc, "this is a comment")
-        doc.root.add_previous_sibling comment
-        assert_equal [comment, doc.root], doc.children.to_a
-      end
-
-      def test_document_root_can_have_a_processing_instruction_sibling_via_add_child
-        doc = Nokogiri::XML "<root>foo</root>"
-        pi = Nokogiri::XML::ProcessingInstruction.new(doc, "xml-stylesheet", %q{type="text/xsl" href="foo.xsl"})
-        doc.add_child pi
-        assert_equal [doc.root, pi], doc.children.to_a
-      end
-
-      def test_document_root_can_have_a_processing_instruction_sibling_via_prepend_child
-        doc = Nokogiri::XML "<root>foo</root>"
-        pi = Nokogiri::XML::ProcessingInstruction.new(doc, "xml-stylesheet", %q{type="text/xsl" href="foo.xsl"})
-        doc.prepend_child pi
-        assert_equal [pi, doc.root], doc.children.to_a
-      end
-
-      def test_document_root_can_have_a_processing_instruction_sibling_via_add_next_sibling
-        doc = Nokogiri::XML "<root>foo</root>"
-        pi = Nokogiri::XML::ProcessingInstruction.new(doc, "xml-stylesheet", %q{type="text/xsl" href="foo.xsl"})
-        doc.root.add_next_sibling pi
-        assert_equal [doc.root, pi], doc.children.to_a
-      end
-
-      def test_document_root_can_have_a_processing_instruction_sibling_via_add_previous_sibling
-        doc = Nokogiri::XML "<root>foo</root>"
-        pi = Nokogiri::XML::ProcessingInstruction.new(doc, "xml-stylesheet", %q{type="text/xsl" href="foo.xsl"})
-        doc.root.add_previous_sibling pi
-        assert_equal [pi, doc.root], doc.children.to_a
-      end
-
-      def test_find_by_css_with_tilde_eql
-        xml = Nokogiri::XML.parse(<<-eoxml)
-        <root>
-          <a>Hello world</a>
-          <a class='foo bar'>Bar</a>
-          <a class='bar foo'>Bar</a>
-          <a class='bar'>Bar</a>
-          <a class='baz bar foo'>Bar</a>
-          <a class='bazbarfoo'>Awesome</a>
-          <a class='bazbar'>Awesome</a>
-        </root>
-        eoxml
-        set = xml.css('a[@class~="bar"]')
-        assert_equal 4, set.length
-        assert_equal ['Bar'], set.map { |node| node.content }.uniq
-      end
-
-      def test_unlink
-        xml = Nokogiri::XML.parse(<<-eoxml)
-        <root>
-          <a class='foo bar'>Bar</a>
-          <a class='bar foo'>Bar</a>
-          <a class='bar'>Bar</a>
-          <a>Hello world</a>
-          <a class='baz bar foo'>Bar</a>
-          <a class='bazbarfoo'>Awesome</a>
-          <a class='bazbar'>Awesome</a>
-        </root>
-        eoxml
-        node = xml.xpath('.//a')[3]
-        assert_equal('Hello world', node.text)
-        assert_match(/Hello world/, xml.to_s)
-        assert node.parent
-        assert node.document
-        assert node.previous_sibling
-        assert node.next_sibling
-        node.unlink
-        assert !node.parent
-        # assert !node.document
-        assert !node.previous_sibling
-        assert !node.next_sibling
-        assert_no_match(/Hello world/, xml.to_s)
-      end
-
-      def test_next_sibling
-        assert sibling = @node.child.next_sibling
-        assert_equal('employee', sibling.name)
-      end
-
-      def test_previous_sibling
-        assert sibling = @node.child.next_sibling
-        assert_equal('employee', sibling.name)
-        assert_equal(sibling.previous_sibling, @node.child)
-      end
-
-      def test_name=
-        @node.name = 'awesome'
-        assert_equal('awesome', @node.name)
-      end
-
-      def test_child
-        assert child = @node.child
-        assert_equal('text', child.name)
-      end
-
-      def test_key?
-        assert node = @node.search('.//address').first
-        assert(!node.key?('asdfasdf'))
-      end
-
-      def test_set_property
-        assert node = @node.search('.//address').first
-        node['foo'] = 'bar'
-        assert_equal('bar', node['foo'])
-      end
-
-      def test_attributes
-        assert node = @node.search('.//address').first
-        assert_nil(node['asdfasdfasdf'])
-        assert_equal('Yes', node['domestic'])
-
-        assert node = @node.search('.//address')[2]
-        attr = node.attributes
-        assert_equal 2, attr.size
-        assert_equal 'Yes', attr['domestic'].value
-        assert_equal 'Yes', attr['domestic'].to_s
-        assert_equal 'No', attr['street'].value
-      end
-
-      def test_path
-        assert set = @node.search('.//employee')
-        assert node = set.first
-        assert_equal('/staff/employee[1]', node.path)
-      end
-
-      def test_search_by_symbol
-        assert set = @node.search(:employee)
-        assert 5, set.length
-
-        assert node = @node.at(:employee)
-        assert node.text =~ /EMP0001/
-      end
-
-      def test_new_node
-        node = Nokogiri::XML::Node.new('form', @node.document)
-        assert_equal('form', node.name)
-        assert(node.document)
-      end
-
-      def test_encode_special_chars
-        foo = @node.css('employee').first.encode_special_chars('&')
-        assert_equal '&amp;', foo
-      end
-
-      def test_content
-        node = Nokogiri::XML::Node.new('form', @node)
-        assert_equal('', node.content)
-
-        node.content = 'hello world!'
-        assert_equal('hello world!', node.content)
-      end
-
-      def test_whitespace_nodes
-        doc = Nokogiri::XML.parse("<root><b>Foo</b>\n<i>Bar</i> <p>Bazz</p></root>")
-        children = doc.at('.//root').children.collect(&:to_s)
-        assert_equal "\n", children[1]
-        assert_equal " ", children[3]
-      end
-
-      def test_replace
-        set = @node.search('.//employee')
-        assert 5, set.length
-        assert 0, @node.search('.//form').length
-
-        first = set[0]
-        second = set[1]
-
-        node = Nokogiri::XML::Node.new('form', @node)
-        first.replace(node)
-
-        assert set = @node.search('.//employee')
-        assert_equal 4, set.length
-        assert 1, @node.search('.//form').length
-
-        assert_equal set[0].to_xml, second.to_xml
-      end
-
-      def test_replace_on_unparented_node
-        foo = Node.new('foo', @node.document)
-        if Nokogiri.jruby? # JRuby Nokogiri doesn't raise an exception
-          @node.replace(foo)
-        else
-          assert_raises(RuntimeError){ @node.replace(foo) }
-        end
-      end
-
-      def test_illegal_replace_of_node_with_doc
-        new_node = Nokogiri::XML.parse('<foo>bar</foo>')
-        old_node = @node.at('.//employee')
-        assert_raises(ArgumentError){ old_node.replace new_node }
-      end
-
-      def test_unlink_on_unlinked_node_1
-        node = Nokogiri::XML::Node.new 'div', Nokogiri::XML::Document.new
-        node.unlink # must_not_raise
-        assert_nil node.parent
-      end
-
-      def test_unlink_on_unlinked_node_2
-        node = Nokogiri::XML('<div>foo</div>').at_css("div")
-        node.unlink
-        node.unlink # must_not_raise
-        assert_nil node.parent
-      end
-    end
-  end
-end