rubyjedi-nokogiri_java 1.4.0.20100513161003-java

data/test/xml/test_node_attributes.rb

@@ -0,0 +1,34 @@
+require "helper"
+
+module Nokogiri
+  module XML
+    class TestNodeAttributes < Nokogiri::TestCase
+      def test_attribute_with_ns
+        doc = Nokogiri::XML <<-eoxml
+          <root xmlns:tlm='http://tenderlovemaking.com/'>
+            <node tlm:foo='bar' foo='baz' />
+          </root>
+        eoxml
+
+        node = doc.at('node')
+
+        assert_equal 'bar',
+          node.attribute_with_ns('foo', 'http://tenderlovemaking.com/').value
+      end
+
+      def test_namespace_key?
+        doc = Nokogiri::XML <<-eoxml
+          <root xmlns:tlm='http://tenderlovemaking.com/'>
+            <node tlm:foo='bar' foo='baz' />
+          </root>
+        eoxml
+
+        node = doc.at('node')
+
+        assert node.namespaced_key?('foo', 'http://tenderlovemaking.com/')
+        assert node.namespaced_key?('foo', nil)
+        assert !node.namespaced_key?('foo', 'foo')
+      end
+    end
+  end
+end

data/test/xml/test_node_encoding.rb

@@ -0,0 +1,107 @@
+require "helper"
+
+module Nokogiri
+  module XML
+    if RUBY_VERSION =~ /^1\.9/
+      class TestNodeEncoding < Nokogiri::TestCase
+        def setup
+          super
+          @html = Nokogiri::HTML(File.read(HTML_FILE), HTML_FILE)
+        end
+
+        def test_get_attribute
+          node = @html.css('a').first
+          assert_equal @html.encoding, node['href'].encoding.name
+        end
+
+        def test_text_encoding_is_utf_8
+          @html = Nokogiri::HTML(File.open(NICH_FILE))
+          assert_equal 'UTF-8', @html.text.encoding.name
+        end
+
+        def test_serialize_encoding_html
+          @html = Nokogiri::HTML(File.open(NICH_FILE))
+          assert_equal @html.encoding.downcase,
+            @html.serialize.encoding.name.downcase
+
+          @doc = Nokogiri::HTML(@html.serialize)
+          assert_equal @html.serialize, @doc.serialize
+        end
+
+        def test_serialize_encoding_xml
+          @xml = Nokogiri::XML(File.open(SHIFT_JIS_XML))
+          assert_equal @xml.encoding.downcase,
+            @xml.serialize.encoding.name.downcase
+
+          @doc = Nokogiri::XML(@xml.serialize)
+          assert_equal @xml.serialize, @doc.serialize
+        end
+
+        def test_encode_special_chars
+          foo = @html.css('a').first.encode_special_chars('foo')
+          assert_equal @html.encoding, foo.encoding.name
+        end
+
+        def test_content
+          node = @html.css('a').first
+          assert_equal @html.encoding, node.content.encoding.name
+        end
+
+        def test_name
+          node = @html.css('a').first
+          assert_equal @html.encoding, node.name.encoding.name
+        end
+
+        def test_path
+          node = @html.css('a').first
+          assert_equal @html.encoding, node.path.encoding.name
+        end
+
+        def test_namespace
+          xml = <<-eoxml
+<root>
+ <car xmlns:part="http://general-motors.com/">
+  <part:tire>Michelin Model XGV</part:tire>
+ </car>
+ <bicycle xmlns:part="http://schwinn.com/">
+  <part:tire>I'm a bicycle tire!</part:tire>
+ </bicycle>
+</root>
+          eoxml
+          doc = Nokogiri::XML(xml, nil, 'UTF-8')
+          assert_equal 'UTF-8', doc.encoding
+          n = doc.xpath('//part:tire', { 'part' => 'http://schwinn.com/' }).first
+          assert n
+          assert_equal doc.encoding, n.namespace.href.encoding.name
+          assert_equal doc.encoding, n.namespace.prefix.encoding.name
+        end
+
+        def test_namespace_as_hash
+          xml = <<-eoxml
+<root>
+ <car xmlns:part="http://general-motors.com/">
+  <part:tire>Michelin Model XGV</part:tire>
+ </car>
+ <bicycle xmlns:part="http://schwinn.com/">
+  <part:tire>I'm a bicycle tire!</part:tire>
+ </bicycle>
+</root>
+          eoxml
+          doc = Nokogiri::XML(xml, nil, 'UTF-8')
+          assert_equal 'UTF-8', doc.encoding
+          assert n = doc.xpath('//car').first
+
+          n.namespace_definitions.each do |nd|
+            assert_equal doc.encoding, nd.href.encoding.name
+            assert_equal doc.encoding, nd.prefix.encoding.name
+          end
+
+          n.namespaces.each do |k,v|
+            assert_equal doc.encoding, k.encoding.name
+            assert_equal doc.encoding, v.encoding.name
+          end
+        end
+      end
+    end
+  end
+end

data/test/xml/test_node_reparenting.rb

@@ -0,0 +1,279 @@
+require "helper"
+
+module Nokogiri
+  module XML
+    class TestNodeReparenting < Nokogiri::TestCase
+
+      def setup
+        super
+        @xml = Nokogiri::XML "<root><a1>First node</a1><a2>Second node</a2><a3>Third node</a3></root>"
+      end
+
+      def test_add_child_should_insert_at_end_of_children
+        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_equal @xml.root.children.last.content, 'hello'
+      end
+
+      def test_add_child_fragment_should_insert_fragment_roots_at_end_of_children
+        node = @xml.root.children[1]
+        fragment = Nokogiri::XML.fragment("<b1>foo</b1><b2>bar</b2>")
+        fc1 = fragment.children[0]
+        fc2 = fragment.children[1]
+
+        node.add_child fragment
+
+        assert_equal 3, node.children.length
+        assert_equal fc1, node.children[1]
+        assert_equal fc2, node.children[2]
+      end
+
+      def test_chevron_works_as_add_child
+        text_node = Nokogiri::XML::Text.new('hello', @xml)
+        assert_equal Nokogiri::XML::Node::TEXT_NODE, text_node.type
+
+        @xml.root << text_node
+
+        assert_equal @xml.root.children.last.content, 'hello'
+      end
+
+      def test_add_child_already_in_the_document_should_move_the_node
+        third_node = @xml.root.children.last
+        first_node = @xml.root.children.first
+
+        @xml.root.add_child(first_node)
+
+        assert_equal 2, @xml.root.children.index(first_node)
+        assert_equal 1, @xml.root.children.index(third_node)
+      end
+
+      def test_add_child_from_other_document_should_remove_from_old_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 |item|
+          d1.at('root').add_child item
+        end
+
+        assert_equal 0, d2.search('item').size
+        assert_equal 4, d1.search('item').size
+      end
+
+      def test_add_child_text_node_should_merge_with_adjacent_text_nodes
+        node = @xml.root.children.first
+        old_child = node.children.first
+        new_child = Nokogiri::XML::Text.new('text', @xml)
+
+        node.add_child new_child
+
+        assert_equal "First nodetext", node.children.first.content
+        assert_equal "First nodetext", new_child.content
+        assert_equal "First nodetext", old_child.content
+      end
+
+      def test_add_child_node_following_sequential_text_nodes_should_have_right_path
+        node = @xml.root.children.first
+        node.add_child(Nokogiri::XML::Text.new('text', @xml))
+
+        item = node.add_child(Nokogiri::XML::Element.new('item', @xml))
+
+        assert_equal '/root/a1/item', item.path
+      end
+
+      def test_add_child_node_with_namespace_should_keep_namespace
+        doc   = Nokogiri::XML::Document.new
+        item  = Nokogiri::XML::Element.new('item', doc)
+        doc.root = item
+
+        entry = Nokogiri::XML::Element.new('entry', doc)
+        entry.add_namespace('tlm', 'http://tenderlovemaking.com')
+        assert_equal 'http://tenderlovemaking.com', entry.namespaces['xmlns:tlm']
+        item.add_child(entry)
+        assert_equal 'http://tenderlovemaking.com', entry.namespaces['xmlns:tlm']
+      end
+
+      def test_add_child_node_should_inherit_namespace
+        doc = Nokogiri::XML(<<-eoxml)
+          <root xmlns="http://tenderlovemaking.com/">
+            <first>
+            </first>
+          </root>
+        eoxml
+        assert node = doc.at('//xmlns:first')
+        child = Nokogiri::XML::Node.new('second', doc)
+        node.add_child(child)
+        assert doc.at('//xmlns:second')
+      end
+
+      def test_add_child_node_should_not_inherit_namespace_if_it_has_one
+        doc = Nokogiri::XML(<<-eoxml)
+          <root xmlns="http://tenderlovemaking.com/" xmlns:foo="http://flavorjon.es/">
+            <first>
+            </first>
+          </root>
+        eoxml
+        assert node = doc.at('//xmlns:first')
+        child = Nokogiri::XML::Node.new('second', doc)
+
+        ns = doc.root.namespace_definitions.detect { |x| x.prefix == "foo" }
+        child.namespace = ns
+
+        node.add_child(child)
+        assert doc.at('//foo:second', "foo" => "http://flavorjon.es/")
+      end
+
+      def test_replace_node_should_remove_previous_node_and_insert_new_node
+        second_node = @xml.root.children[1]
+
+        new_node = Nokogiri::XML::Node.new('foo', @xml)
+        second_node.replace(new_node)
+
+        assert_equal @xml.root.children[1], new_node
+        assert_nil second_node.parent
+      end
+
+      def test_replace_fragment_should_replace_node_with_fragment_roots
+        node = @xml.root.children[1]
+        fragment = Nokogiri::XML.fragment("<b1>foo</b1><b2>bar</b2>")
+        fc1 = fragment.children[0]
+        fc2 = fragment.children[1]
+
+        node.replace fragment
+
+        assert_equal 4, @xml.root.children.length
+        assert_equal fc1, @xml.root.children[1]
+        assert_equal fc2, @xml.root.children[2]
+      end
+
+      def test_replace_with_default_namespaces
+        fruits = Nokogiri::XML(<<-eoxml)
+          <fruit xmlns="http://fruits.org">
+            <apple />
+          </fruit>
+        eoxml
+
+        apple = fruits.css('apple').first
+
+        orange = Nokogiri::XML::Node.new('orange', fruits)
+        apple.replace(orange)
+
+        assert_equal orange, fruits.css('orange').first
+      end
+
+      def test_illegal_replace_of_node_with_doc
+        new_node = Nokogiri::XML.parse('<foo>bar</foo>')
+        old_node = @xml.at_css('a1')
+        assert_raises(ArgumentError){ old_node.replace new_node }
+      end
+
+      def test_replace_with_node_from_different_docs
+        xml1 = "<test> <caption>Original caption</caption> </test>"
+        xml2 = "<test> <caption>Replacement caption</caption> </test>"
+        doc1 = Nokogiri::XML(xml1)
+        doc2 = Nokogiri::XML(xml2)
+        caption1 = doc1.xpath("//caption")[0]
+        caption2 = doc2.xpath("//caption")[0]
+        caption1.replace(caption2) # this segfaulted under 1.4.0 and earlier
+        assert_equal "Replacement caption", doc1.css("caption").inner_text
+      end
+
+      def test_add_next_sibling_should_insert_after
+        node = @xml.root.children[1]
+        new_node = Nokogiri::XML::Node.new('foo', @xml)
+
+        node.add_next_sibling(new_node)
+        assert_equal 1, @xml.root.children.index(node)
+        assert_equal 2, @xml.root.children.index(new_node)
+      end
+
+      def test_add_next_sibling_fragment_should_insert_fragment_roots_after
+        node = @xml.root.children[1]
+        fragment = Nokogiri::XML.fragment("<b1>foo</b1><b2>bar</b2>")
+        fc1 = fragment.children[0]
+        fc2 = fragment.children[1]
+
+        node.add_next_sibling fragment
+
+        assert_equal 5, @xml.root.children.length
+        assert_equal fc1, @xml.root.children[2]
+        assert_equal fc2, @xml.root.children[3]
+      end
+
+      def test_add_next_sibling_text_node_should_merge_with_adjacent_text_nodes
+        node = @xml.root.children.first
+        text = node.children.first
+        new_text = Nokogiri::XML::Text.new('text', @xml)
+
+        text.add_next_sibling new_text
+
+        assert_equal "First nodetext", node.children.first.content
+        assert_equal "First nodetext", text.content
+        assert_equal "First nodetext", new_text.content
+      end
+
+      def test_add_previous_sibling_should_insert_before
+        node = @xml.root.children[1]
+        new_node = Nokogiri::XML::Node.new('foo', @xml)
+
+        node.add_previous_sibling(new_node)
+        assert_equal 1, @xml.root.children.index(new_node)
+        assert_equal 2, @xml.root.children.index(node)
+      end
+
+      def test_add_previous_sibling_fragment_should_insert_fragment_roots_before
+        node = @xml.root.children[1]
+        fragment = Nokogiri::XML.fragment("<b1>foo</b1><b2>bar</b2>")
+        fc1 = fragment.children[0]
+        fc2 = fragment.children[1]
+
+        node.add_previous_sibling fragment
+
+        assert_equal 5, @xml.root.children.length
+        assert_equal fc1, @xml.root.children[1]
+        assert_equal fc2, @xml.root.children[2]
+      end
+
+      def test_add_previous_sibling_text_node_should_merge_with_adjacent_text_nodes
+        node = @xml.root.children.first
+        text = node.children.first
+        new_text = Nokogiri::XML::Text.new('text', @xml)
+
+        text.add_previous_sibling new_text
+
+        assert_equal "textFirst node", node.children.first.content
+        assert_equal "textFirst node", text.content
+        assert_equal "textFirst node", new_text.content
+      end
+
+      def test_unlink_then_reparent
+        # see http://github.com/tenderlove/nokogiri/issues#issue/22
+        10.times do
+          STDOUT.putc "."
+          STDOUT.flush
+          begin
+            doc = Nokogiri::XML <<-EOHTML
+              <root>
+                <a>
+                  <b/>
+                  <c/>
+                </a>
+              </root>
+            EOHTML
+
+            root = doc.at("root")
+            a = root.at("a")
+            b = a.at("b")
+            c = a.at("c")
+            a.add_next_sibling(b.unlink)
+            c.unlink
+          end
+          GC.start
+        end
+      end
+
+    end
+  end
+end

data/test/xml/test_node_set.rb

@@ -0,0 +1,577 @@
+require "helper"
+
+module Nokogiri
+  module XML
+    class TestNodeSet < Nokogiri::TestCase
+      def setup
+        super
+        @xml = Nokogiri::XML(File.read(XML_FILE), XML_FILE)
+        @list = @xml.css('employee')
+      end
+
+      def test_remove_attr
+        @list.each { |x| x['class'] = 'blah' }
+        assert_equal @list, @list.remove_attr('class')
+        @list.each { |x| assert_nil x['class'] }
+      end
+
+      def test_add_class
+        assert_equal @list, @list.add_class('bar')
+        @list.each { |x| assert_equal 'bar', x['class'] }
+
+        @list.add_class('bar')
+        @list.each { |x| assert_equal 'bar', x['class'] }
+
+        @list.add_class('baz')
+        @list.each { |x| assert_equal 'bar baz', x['class'] }
+      end
+
+      def test_remove_class_with_no_class
+        assert_equal @list, @list.remove_class('bar')
+        @list.each { |e| assert_nil e['class'] }
+
+        @list.each { |e| e['class'] = '' }
+        assert_equal @list, @list.remove_class('bar')
+        @list.each { |e| assert_nil e['class'] }
+      end
+
+      def test_remove_class_single
+        @list.each { |e| e['class'] = 'foo bar' }
+
+        assert_equal @list, @list.remove_class('bar')
+        @list.each { |e| assert_equal 'foo', e['class'] }
+      end
+
+      def test_remove_class_completely
+        @list.each { |e| e['class'] = 'foo' }
+
+        assert_equal @list, @list.remove_class
+        @list.each { |e| assert_nil e['class'] }
+      end
+
+      def test_attribute_set
+        @list.each { |e| assert_nil e['foo'] }
+
+        [ ['attribute', 'bar'], ['attr', 'biz'], ['set', 'baz'] ].each do |t|
+          @list.send(t.first.to_sym, 'foo', t.last)
+          @list.each { |e| assert_equal t.last, e['foo'] }
+        end
+      end
+
+      def test_attribute_set_with_block
+        @list.each { |e| assert_nil e['foo'] }
+
+        [ ['attribute', 'bar'], ['attr', 'biz'], ['set', 'baz'] ].each do |t|
+          @list.send(t.first.to_sym, 'foo') { |x| t.last }
+          @list.each { |e| assert_equal t.last, e['foo'] }
+        end
+      end
+
+      def test_attribute_set_with_hash
+        @list.each { |e| assert_nil e['foo'] }
+
+        [ ['attribute', 'bar'], ['attr', 'biz'], ['set', 'baz'] ].each do |t|
+          @list.send(t.first.to_sym, 'foo' => t.last)
+          @list.each { |e| assert_equal t.last, e['foo'] }
+        end
+      end
+
+      def test_attribute_no_args
+        @list.first['foo'] = 'bar'
+        assert_equal @list.first.attribute('foo'), @list.attribute('foo')
+      end
+
+      def test_search_empty_node_set
+        set = Nokogiri::XML::NodeSet.new(Nokogiri::XML::Document.new)
+        assert_equal 0, set.css('foo').length
+        assert_equal 0, set.xpath('.//foo').length
+        assert_equal 0, set.search('foo').length
+      end
+
+      def test_xpath_with_custom_object
+        set = @xml.xpath('//staff')
+        custom_employees = set.xpath('//*[awesome(.)]', Class.new {
+          def awesome ns
+            ns.select { |n| n.name == 'employee' }
+          end
+        }.new)
+
+        assert_equal @xml.xpath('//employee'), custom_employees
+      end
+
+      def test_css_with_custom_object
+        set = @xml.xpath('//staff')
+        custom_employees = set.css('*:awesome', Class.new {
+          def awesome ns
+            ns.select { |n| n.name == 'employee' }
+          end
+        }.new)
+
+        assert_equal @xml.xpath('//employee'), custom_employees
+      end
+
+      def test_search_with_custom_object
+        set = @xml.xpath('//staff')
+        custom_employees = set.search('//*[awesome(.)]', Class.new {
+          def awesome ns
+            ns.select { |n| n.name == 'employee' }
+          end
+        }.new)
+
+        assert_equal @xml.xpath('//employee'), custom_employees
+      end
+
+      def test_css_searches_match_self
+        html = Nokogiri::HTML("<html><body><div class='a'></div></body></html>")
+        set = html.xpath("/html/body/div")
+        assert_equal set.first, set.css(".a").first
+      end
+
+      def test_search_with_css_matches_self
+        html = Nokogiri::HTML("<html><body><div class='a'></div></body></html>")
+        set = html.xpath("/html/body/div")
+        assert_equal set.first, set.search(".a").first
+      end
+
+      def test_double_equal
+        assert node_set_one = @xml.xpath('//employee')
+        assert node_set_two = @xml.xpath('//employee')
+
+        assert_not_equal node_set_one.object_id, node_set_two.object_id
+
+        assert_equal node_set_one, node_set_two
+      end
+
+      def test_node_set_not_equal_to_string
+        node_set_one = @xml.xpath('//employee')
+        assert_not_equal node_set_one, "asdfadsf"
+      end
+
+      def test_out_of_order_not_equal
+        one = @xml.xpath('//employee')
+        two = @xml.xpath('//employee')
+        two.push two.shift
+        assert_not_equal one, two
+      end
+
+      def test_shorter_is_not_equal
+        node_set_one = @xml.xpath('//employee')
+        node_set_two = @xml.xpath('//employee')
+        node_set_two.delete(node_set_two.first)
+
+        assert_not_equal node_set_one, node_set_two
+      end
+
+      def test_pop
+        set = @xml.xpath('//employee')
+        last = set.last
+        assert_equal last, set.pop
+      end
+
+      def test_shift
+        set = @xml.xpath('//employee')
+        first = set.first
+        assert_equal first, set.shift
+      end
+
+      def test_shift_empty
+        set = Nokogiri::XML::NodeSet.new(@xml)
+        assert_nil set.shift
+      end
+
+      def test_pop_empty
+        set = Nokogiri::XML::NodeSet.new(@xml)
+        assert_nil set.pop
+      end
+
+      def test_first_takes_arguments
+        assert node_set = @xml.xpath('//employee')
+        assert_equal 2, node_set.first(2).length
+      end
+
+      def test_dup
+        assert node_set = @xml.xpath('//employee')
+        dup = node_set.dup
+        assert_equal node_set.length, dup.length
+        node_set.zip(dup).each do |a,b|
+          assert_equal a, b
+        end
+      end
+
+      def test_xmlns_is_automatically_registered
+        doc = Nokogiri::XML(<<-eoxml)
+          <root xmlns="http://tenderlovemaking.com/">
+            <foo>
+              <bar/>
+            </foo>
+          </root>
+        eoxml
+        set = doc.css('foo')
+        assert_equal 1, set.css('xmlns|bar').length
+        assert_equal 0, set.css('|bar').length
+        assert_equal 1, set.xpath('//xmlns:bar').length
+        assert_equal 1, set.search('xmlns|bar').length
+        assert_equal 1, set.search('//xmlns:bar').length
+        assert set.at('//xmlns:bar')
+        assert set.at('xmlns|bar')
+        assert set.at('bar')
+      end
+
+      def test_children_has_document
+        set = @xml.root.children
+        assert_instance_of(NodeSet, set)
+        assert_equal @xml, set.document
+      end
+
+      def test_length_size
+        assert node_set = @xml.search('//employee')
+        assert_equal node_set.length, node_set.size
+      end
+
+      def test_to_xml
+        assert node_set = @xml.search('//employee')
+        assert node_set.to_xml
+      end
+
+      def test_inner_html
+        doc = Nokogiri::HTML(<<-eohtml)
+          <html>
+            <body>
+              <div>
+                <a>one</a>
+              </div>
+              <div>
+                <a>two</a>
+              </div>
+            </body>
+          </html>
+        eohtml
+        assert html = doc.css('div').inner_html
+        assert_match '<a>', html
+      end
+
+      def test_at
+        assert node_set = @xml.search('//employee')
+        assert_equal node_set.first, node_set.at(0)
+      end
+
+      def test_percent
+        assert node_set = @xml.search('//employee')
+        assert_equal node_set.first, node_set % 0
+      end
+
+      def test_to_ary
+        assert node_set = @xml.search('//employee')
+        foo = []
+        foo += node_set
+        assert_equal node_set.length, foo.length
+      end
+
+      def test_push
+        node = Nokogiri::XML::Node.new('foo', @xml)
+        node.content = 'bar'
+
+        assert node_set = @xml.search('//employee')
+        node_set.push(node)
+
+        assert node_set.include?(node)
+      end
+
+      def test_delete_with_invalid_argument
+        employees = @xml.search("//employee")
+        positions = @xml.search("//position")
+
+        assert_raises(ArgumentError) { employees.delete(positions) }
+      end
+
+      def test_delete_when_present
+        employees = @xml.search("//employee")
+        wally = employees.first
+        assert employees.include?(wally) # testing setup
+        length = employees.length
+
+        result = employees.delete(wally)
+        assert_equal result, wally
+        assert ! employees.include?(wally)
+        assert length-1, employees.length
+      end
+
+      def test_delete_when_not_present
+        employees = @xml.search("//employee")
+        phb = @xml.search("//position").first
+        assert ! employees.include?(phb) # testing setup
+        length = employees.length
+
+        result = employees.delete(phb)
+        assert_nil result
+        assert length, employees.length
+      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
+        set = xml.xpath('//a')
+        set.unlink
+        set.each do |node|
+          assert !node.parent
+          #assert !node.document
+          assert !node.previous_sibling
+          assert !node.next_sibling
+        end
+        assert_no_match(/Hello world/, xml.to_s)
+      end
+
+      def test_nodeset_search_takes_namespace
+        @xml = Nokogiri::XML.parse(<<-eoxml)
+<root>
+ <car xmlns:part="http://general-motors.com/">
+  <part:tire>Michelin Model XGV</part:tire>
+ </car>
+ <bicycle xmlns:part="http://schwinn.com/">
+  <part:tire>I'm a bicycle tire!</part:tire>
+ </bicycle>
+</root>
+        eoxml
+        set = @xml/'root'
+        assert_equal 1, set.length
+        bike_tire = set.search('//bike:tire', 'bike' => "http://schwinn.com/")
+        assert_equal 1, bike_tire.length
+      end
+
+      def test_new_nodeset
+        node_set = Nokogiri::XML::NodeSet.new(@xml)
+        assert_equal(0, node_set.length)
+        node = Nokogiri::XML::Node.new('form', @xml)
+        node_set << node
+        assert_equal(1, node_set.length)
+        assert_equal(node, node_set.last)
+      end
+
+      def test_search_on_nodeset
+        assert node_set = @xml.search('//employee')
+        assert sub_set = node_set.search('.//name')
+        assert_equal(node_set.length, sub_set.length)
+      end
+
+      def test_negative_index_works
+        assert node_set = @xml.search('//employee')
+        assert_equal node_set.last, node_set[-1]
+      end
+
+      def test_large_negative_index_returns_nil
+        assert node_set = @xml.search('//employee')
+        assert_nil(node_set[-1 * (node_set.length + 1)])
+      end
+
+      def test_node_set_fetches_private_data
+        assert node_set = @xml.search('//employee')
+
+        set = node_set
+        assert_equal(set[0], set[0])
+      end
+
+      def test_node_set_returns_0
+        assert node_set = @xml.search('//asdkfjhasdlkfjhaldskfh')
+        assert_equal(0, node_set.length)
+      end
+
+      def test_wrap
+        employees = (@xml/"//employee").wrap("<wrapper/>")
+        assert_equal 'wrapper', employees[0].parent.name
+        assert_equal 'employee', @xml.search("//wrapper").first.children[0].name
+      end
+
+      def test_wrap_preserves_document_structure
+        assert_equal "employeeId",
+                     @xml.at_xpath("//employee").children.detect{|j| ! j.text? }.name
+        @xml.xpath("//employeeId[text()='EMP0001']").wrap("<wrapper/>")
+        assert_equal "wrapper",
+                     @xml.at_xpath("//employee").children.detect{|j| ! j.text? }.name
+      end
+
+      def test_plus_operator
+        names = @xml.search("name")
+        positions = @xml.search("position")
+
+        names_len = names.length
+        positions_len = positions.length
+
+        assert_raises(ArgumentError) { result = names + positions.first }
+
+        result = names + positions
+        assert_equal names_len,                         names.length
+        assert_equal positions_len,                     positions.length
+        assert_equal names.length + positions.length,   result.length
+
+        names += positions
+        assert_equal result.length, names.length
+      end
+
+      def test_union
+        names = @xml.search("name")
+
+        assert_equal(names.length, (names | @xml.search("name")).length)
+      end
+
+      def test_minus_operator
+        employees = @xml.search("//employee")
+        females = @xml.search("//employee[gender[text()='Female']]")
+
+        employees_len = employees.length
+        females_len = females.length
+
+        assert_raises(ArgumentError) { result = employees - females.first }
+
+        result = employees - females
+        assert_equal employees_len,                     employees.length
+        assert_equal females_len,                       females.length
+        assert_equal employees.length - females.length, result.length
+
+        employees -= females
+        assert_equal result.length, employees.length
+      end
+
+      def test_array_index
+        employees = @xml.search("//employee")
+        other = @xml.search("//position").first
+
+        assert_equal 3, employees.index(employees[3])
+        assert_nil employees.index(other)
+      end
+
+      def test_slice_too_far
+        employees = @xml.search("//employee")
+        assert_equal employees.length, employees[0, employees.length + 1].length
+        assert_equal employees.length, employees[0, employees.length].length
+      end
+
+      def test_array_slice_with_start_and_end
+        employees = @xml.search("//employee")
+        assert_equal [employees[1], employees[2], employees[3]], employees[1,3].to_a
+      end
+
+      def test_array_index_bracket_equivalence
+        employees = @xml.search("//employee")
+        assert_equal [employees[1], employees[2], employees[3]], employees[1,3].to_a
+        assert_equal [employees[1], employees[2], employees[3]], employees.slice(1,3).to_a
+      end
+
+      def test_array_slice_with_negative_start
+        employees = @xml.search("//employee")
+        assert_equal [employees[2]],                    employees[-3,1].to_a
+        assert_equal [employees[2], employees[3]],      employees[-3,2].to_a
+      end
+
+      def test_array_slice_with_invalid_args
+        employees = @xml.search("//employee")
+        assert_nil employees[99, 1] # large start
+        assert_nil employees[1, -1] # negative len
+        assert_equal [], employees[1, 0].to_a # zero len
+      end
+
+      def test_array_slice_with_range
+        employees = @xml.search("//employee")
+        assert_equal [employees[1], employees[2], employees[3]], employees[1..3].to_a
+        assert_equal [employees[0], employees[1], employees[2], employees[3]], employees[0..3].to_a
+      end
+
+      def test_intersection_with_no_overlap
+        employees = @xml.search("//employee")
+        positions = @xml.search("//position")
+
+        assert_equal [], (employees & positions).to_a
+      end
+
+      def test_intersection
+        employees = @xml.search("//employee")
+        first_set = employees[0..2]
+        second_set = employees[2..4]
+
+        assert_equal [employees[2]], (first_set & second_set).to_a
+      end
+
+      def test_include?
+        employees = @xml.search("//employee")
+        yes = employees.first
+        no = @xml.search("//position").first
+
+        assert employees.include?(yes)
+        assert ! employees.include?(no)
+      end
+
+      def test_children
+        employees = @xml.search("//employee")
+        count = 0
+        employees.each do |employee|
+          count += employee.children.length
+        end
+        set = employees.children
+        assert_equal count, set.length
+      end
+
+      def test_inspect
+        employees = @xml.search("//employee")
+        inspected = employees.inspect
+
+        assert_equal "[#{employees.map { |x| x.inspect }.join(', ')}]",
+          inspected
+      end
+
+      def test_should_not_splode_when_accessing_namespace_declarations_in_a_node_set
+        xml = Nokogiri::XML "<foo></foo>"
+        node_set = xml.xpath("//namespace::*")
+        assert_equal 1, node_set.size
+        node = node_set.first
+        node.to_s # segfaults in 1.4.0 and earlier
+
+        # if we haven't segfaulted, let's make sure we handled it correctly
+        assert_instance_of Nokogiri::XML::Namespace, node
+      end
+
+      def test_should_not_splode_when_arrayifying_node_set_containing_namespace_declarations
+        xml = Nokogiri::XML "<foo></foo>"
+        node_set = xml.xpath("//namespace::*")
+        assert_equal 1, node_set.size
+
+        node_array = node_set.to_a
+        node = node_array.first
+        node.to_s # segfaults in 1.4.0 and earlier
+
+        # if we haven't segfaulted, let's make sure we handled it correctly
+        assert_instance_of Nokogiri::XML::Namespace, node
+      end
+
+      def test_should_not_splode_when_unlinking_node_set_containing_namespace_declarations
+        xml = Nokogiri::XML "<foo></foo>"
+        node_set = xml.xpath("//namespace::*")
+        assert_equal 1, node_set.size
+
+        node_set.unlink
+      end
+
+      def test_reverse
+        xml = Nokogiri::XML "<root><a />b<c />d<e /></root>"
+        children = xml.root.children
+        assert_instance_of Nokogiri::XML::NodeSet, children
+
+        reversed = children.reverse
+        assert_equal reversed[0], children[4]
+        assert_equal reversed[1], children[3]
+        assert_equal reversed[2], children[2]
+        assert_equal reversed[3], children[1]
+        assert_equal reversed[4], children[0]
+
+        assert_equal children, children.reverse.reverse
+      end
+    end
+  end
+end