domo 0.0.4 → 0.0.5

data/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.4.4/test/xml/test_node_reparenting.rb

@@ -1,321 +0,0 @@
-require "helper"
-
-module Nokogiri
-  module XML
-    class TestNodeReparenting < Nokogiri::TestCase
-
-      describe "standard node reparenting behavior" do
-        # describe "namespace handling during reparenting" do
-        #   describe "given a Node" do
-        #     describe "with a Namespace" do
-        #       it "keeps the Namespace"
-        #     end
-        #     describe "given a parent Node with a default and a non-default Namespace" do
-        #       describe "passed an Node without a namespace" do
-        #         it "inserts an Node that inherits the default Namespace"
-        #       end
-        #       describe "passed a Node with a Namespace that matches the parent's non-default Namespace" do
-        #         it "inserts a Node that inherits the matching parent Namespace"
-        #       end
-        #     end
-        #   end
-        #   describe "given a markup string" do
-        #     describe "parsed relative to the document" do
-        #       describe "with a Namespace" do
-        #         it "keeps the Namespace"
-        #       end
-        #       describe "given a parent Node with a default and a non-default Namespace" do
-        #         describe "passed an Node without a namespace" do
-        #           it "inserts an Node that inherits the default Namespace"
-        #         end
-        #         describe "passed a Node with a Namespace that matches the parent's non-default Namespace" do
-        #           it "inserts a Node that inherits the matching parent Namespace"
-        #         end
-        #       end
-        #     end
-        #     describe "parsed relative to a specific node" do
-        #       describe "with a Namespace" do
-        #         it "keeps the Namespace"
-        #       end
-        #       describe "given a parent Node with a default and a non-default Namespace" do
-        #         describe "passed an Node without a namespace" do
-        #           it "inserts an Node that inherits the default Namespace"
-        #         end
-        #         describe "passed a Node with a Namespace that matches the parent's non-default Namespace" do
-        #           it "inserts a Node that inherits the matching parent Namespace"
-        #         end
-        #       end
-        #     end
-        #   end
-        # end
-
-        {
-          :add_child            => {:target => "/root/a1",        :returns_self => false, :children_tags => %w[text b1 b2]},
-          :<<                   => {:target => "/root/a1",        :returns_self => false, :children_tags => %w[text b1 b2]},
-
-          :replace              => {:target => "/root/a1/node()", :returns_self => false, :children_tags => %w[b1 b2]},
-          :swap                 => {:target => "/root/a1/node()", :returns_self => true,  :children_tags => %w[b1 b2]},
-
-          :children=            => {:target => "/root/a1",        :returns_self => false, :children_tags => %w[b1 b2]},
-          :inner_html=          => {:target => "/root/a1",        :returns_self => true,  :children_tags => %w[b1 b2]},
-
-          :add_previous_sibling => {:target => "/root/a1/text()", :returns_self => false, :children_tags => %w[b1 b2 text]},
-          :previous=            => {:target => "/root/a1/text()", :returns_self => false, :children_tags => %w[b1 b2 text]},
-          :before               => {:target => "/root/a1/text()", :returns_self => true,  :children_tags => %w[b1 b2 text]},
-
-          :add_next_sibling     => {:target => "/root/a1/text()", :returns_self => false, :children_tags => %w[text b1 b2]},
-          :next=                => {:target => "/root/a1/text()", :returns_self => false, :children_tags => %w[text b1 b2]},
-          :after                => {:target => "/root/a1/text()", :returns_self => true,  :children_tags => %w[text b1 b2]}
-        }.each do |method, params|
-
-          before do
-            @doc  = Nokogiri::XML "<root><a1>First node</a1><a2>Second node</a2><a3>Third <bx />node</a3></root>"
-            @doc2 = @doc.dup
-            @fragment_string = "<b1>foo</b1><b2>bar</b2>"
-            @fragment        = Nokogiri::XML::DocumentFragment.parse @fragment_string
-            @node_set        = Nokogiri::XML("<root><b1>foo</b1><b2>bar</b2></root>").xpath("/root/node()")
-          end
-
-          describe "##{method}" do
-            describe "passed a Node" do
-              [:current, :another].each do |which|
-                describe "passed a Node in the #{which} document" do
-                  before do
-                    @other_doc = which == :current ? @doc : @doc2
-                    @other_node = @other_doc.at_xpath("/root/a2")
-                  end
-
-                  it "unlinks the Node from its previous position" do
-                    @doc.at_xpath(params[:target]).send(method, @other_node)
-                    @other_doc.at_xpath("/root/a2").must_be_nil
-                  end
-
-                  it "inserts the Node in the proper position" do
-                    @doc.at_xpath(params[:target]).send(method, @other_node)
-                    @doc.at_xpath("/root/a1/a2").wont_be_nil
-                  end
-
-                  it "returns the expected value" do
-                    sendee = @doc.at_xpath(params[:target])
-                    result = sendee.send(method, @other_node)
-                    if params[:returns_self]
-                      result.must_equal sendee
-                    else
-                      result.must_equal @other_node
-                    end
-                  end
-                end
-              end
-            end
-            describe "passed a markup string" do
-              it "inserts the fragment roots in the proper position" do
-                @doc.at_xpath(params[:target]).send(method, @fragment_string)
-                @doc.xpath("/root/a1/node()").collect {|n| n.name}.must_equal params[:children_tags]
-              end
-
-              it "returns the expected value" do
-                sendee = @doc.at_xpath(params[:target])
-                result = sendee.send(method, @fragment_string)
-                if params[:returns_self]
-                  result.must_equal sendee
-                else
-                  result.must_be_kind_of Nokogiri::XML::NodeSet
-                  result.to_html.must_equal @fragment_string
-                end
-              end
-            end
-            describe "passed a fragment" do
-              it "inserts the fragment roots in the proper position" do
-                @doc.at_xpath(params[:target]).send(method, @fragment)
-                @doc.xpath("/root/a1/node()").collect {|n| n.name}.must_equal params[:children_tags]
-              end
-            end
-            describe "passed a document" do
-              it "raises an exception" do
-                proc { @doc.at_xpath("/root/a1").send(method, @doc2) }.must_raise(ArgumentError)
-              end
-            end
-            describe "passed a non-Node" do
-              it "raises an exception" do
-                proc { @doc.at_xpath("/root/a1").send(method, 42) }.must_raise(ArgumentError)
-              end
-            end
-            describe "passed a NodeSet" do
-              it "inserts each member of the NodeSet in the proper order" do
-                @doc.at_xpath(params[:target]).send(method, @node_set)
-                @doc.xpath("/root/a1/node()").collect {|n| n.name}.must_equal params[:children_tags]
-              end
-            end
-          end
-        end
-
-        describe "text node merging" do
-          describe "#add_child" do
-            it "merges the Text node with adjacent Text nodes" do
-              @doc.at_xpath("/root/a1").add_child Nokogiri::XML::Text.new('hello', @doc)
-              @doc.at_xpath("/root/a1/text()").content.must_equal "First nodehello"
-            end
-          end
-          describe "#replace" do
-            it "merges the Text node with adjacent Text nodes" do
-              @doc.at_xpath("/root/a3/bx").replace Nokogiri::XML::Text.new('hello', @doc)
-              @doc.at_xpath("/root/a3/text()").content.must_equal "Third hellonode"
-            end
-          end
-        end
-      end
-
-      describe "ad hoc node reparenting behavior" do
-        describe "#add_child" do
-          describe "given a new node with a namespace" do
-            it "keeps the namespace" do
-              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
-          end
-
-          describe "given a parent node with a default namespace" do
-            before do
-              @doc = Nokogiri::XML(<<-eoxml)
-                <root xmlns="http://tenderlovemaking.com/">
-                  <first>
-                  </first>
-                </root>
-              eoxml
-            end
-
-            it "inserts a node that inherits the default namespace" do
-              assert node = @doc.at('//xmlns:first')
-              child = Nokogiri::XML::Node.new('second', @doc)
-              node.add_child(child)
-              assert @doc.at('//xmlns:second')
-            end
-          end
-
-          describe "given a parent node with a non-default namespace" do
-            before do
-              @doc = Nokogiri::XML(<<-eoxml)
-                <root xmlns="http://tenderlovemaking.com/" xmlns:foo="http://flavorjon.es/">
-                  <first>
-                  </first>
-                </root>
-              eoxml
-            end
-
-            describe "and a child node with a namespace matching the parent's non-default namespace" do
-              it "inserts a node that inherits the matching parent namespace" do
-                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
-            end
-          end
-        end
-
-        describe "#add_previous_sibling" do
-          it "should not merge text nodes during the operation" do
-            xml = Nokogiri::XML %Q(<root>text node</root>)
-            replacee = xml.root.children.first
-            replacee.add_previous_sibling "foo <p></p> bar"
-            assert_equal "foo <p></p> bartext node", xml.root.children.to_html
-          end
-        end
-
-        describe "#add_next_sibling" do
-          it "should not merge text nodes during the operation" do
-            xml = Nokogiri::XML %Q(<root>text node</root>)
-            replacee = xml.root.children.first
-            replacee.add_next_sibling "foo <p></p> bar"
-            assert_equal "text nodefoo <p></p> bar", xml.root.children.to_html
-          end
-        end
-
-        describe "#replace" do
-          describe "a text node with a text node" do
-            it "should not merge text nodes during the operation" do
-              xml = Nokogiri::XML %Q(<root>text node</root>)
-              replacee = xml.root.children.first
-              replacee.replace "new text node"
-              assert_equal "new text node", xml.root.children.first.content
-            end
-          end
-
-          describe "when a document has a default namespace" do
-            before do
-              @fruits = Nokogiri::XML(<<-eoxml)
-                <fruit xmlns="http://fruits.org">
-                  <apple />
-                </fruit>
-              eoxml
-            end
-
-            it "inserts a node with default namespaces" do
-              apple = @fruits.css('apple').first
-
-              orange = Nokogiri::XML::Node.new('orange', @fruits)
-              apple.replace(orange)
-
-              assert_equal orange, @fruits.css('orange').first
-            end
-          end
-        end
-
-        describe "unlinking a node and then reparenting it" do
-          it "not blow up" do
-            # 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
-
-                assert root = doc.at("root")
-                assert a = root.at("a")
-                assert b = a.at("b")
-                assert c = a.at("c")
-                a.add_next_sibling(b.unlink)
-                c.unlink
-              end
-              GC.start
-            end
-          end
-        end
-
-        describe "replace-merging text nodes" do
-          [
-            ['<root>a<br/></root>',  'afoo'],
-            ['<root>a<br/>b</root>', 'afoob'],
-            ['<root><br/>b</root>',  'foob']
-          ].each do |xml, result|
-            it "doesn't blow up on #{xml}" do
-              doc = Nokogiri::XML.parse(xml)
-              saved_nodes = doc.root.children
-              doc.at_xpath("/root/br").replace(Nokogiri::XML::Text.new('foo', doc))
-              saved_nodes.each { |child| child.inspect } # try to cause a crash
-              assert_equal result, doc.at_xpath("/root/text()").inner_text
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.4.4/test/xml/test_node_set.rb

@@ -1,698 +0,0 @@
-require "helper"
-
-module Nokogiri
-  module XML
-    class TestNodeSet < Nokogiri::TestCase
-      class TestNodeSetNamespaces < Nokogiri::TestCase
-        def setup
-          super
-          @xml = Nokogiri.XML('<foo xmlns:n0="http://example.com" />')
-          @list = @xml.xpath('//namespace::*')
-        end
-
-        def test_include?
-          assert @list.include?(@list.first), 'list should have item'
-        end
-
-        def test_push
-          @list.push @list.first
-        end
-
-        def test_delete
-          @list.push @list.first
-          @list.delete @list.first
-        end
-      end
-
-      def setup
-        super
-        @xml = Nokogiri::XML(File.read(XML_FILE), XML_FILE)
-        @list = @xml.css('employee')
-      end
-
-      def test_filter
-        list = @xml.css('address').filter('*[domestic="Yes"]')
-        assert_equal(%w{ Yes } * 4, list.map { |n| n['domestic'] })
-      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_gt_string_arg
-        assert node_set = @xml.search('//employee')
-        assert_equal node_set.xpath('./employeeId'), (node_set > 'employeeId')
-      end
-
-      def test_at
-        assert node_set = @xml.search('//employee')
-        assert_equal node_set.first, node_set.at(0)
-      end
-
-      def test_at_xpath
-        assert node_set = @xml.search('//employee')
-        assert_equal node_set.first.first_element_child, node_set.at_xpath('./employeeId')
-      end
-
-      def test_at_css
-        assert node_set = @xml.search('//employee')
-        assert_equal node_set.first.first_element_child, node_set.at_css('employeeId')
-      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_a_fragment
-        frag = Nokogiri::XML::DocumentFragment.parse <<-EOXML
-          <employees>
-            <employee>hello</employee>
-            <employee>goodbye</employee>
-          </employees>
-        EOXML
-        employees = frag.xpath ".//employee"
-        employees.wrap("<wrapper/>")
-        assert_equal 'wrapper', employees[0].parent.name
-        assert_equal 'employee', frag.at(".//wrapper").children.first.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) { 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) { 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_slice_waaaaaay_off_the_end
-        xml = Nokogiri::XML::Builder.new {
-          root { 100.times { div } }
-        }.doc
-        nodes = xml.css "div"
-        assert_equal 1, nodes.slice(99,  100_000).length
-        assert_equal 0, nodes.slice(100, 100_000).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
-
-      def test_node_set_dup_result_has_document_and_is_decorated
-        x = Module.new do
-          def awesome! ; end
-        end
-        util_decorate(@xml, x)
-        node_set = @xml.css("address")
-        new_set  = node_set.dup
-        assert_equal node_set.document, new_set.document
-        assert new_set.respond_to?(:awesome!)
-      end
-
-      def test_node_set_union_result_has_document_and_is_decorated
-        x = Module.new do
-          def awesome! ; end
-        end
-        util_decorate(@xml, x)
-        node_set1 = @xml.css("address")
-        node_set2 = @xml.css("address")
-        new_set  = node_set1 | node_set2
-        assert_equal node_set1.document, new_set.document
-        assert new_set.respond_to?(:awesome!)
-      end
-
-      def test_node_set_intersection_result_has_document_and_is_decorated
-        x = Module.new do
-          def awesome! ; end
-        end
-        util_decorate(@xml, x)
-        node_set1 = @xml.css("address")
-        node_set2 = @xml.css("address")
-        new_set  = node_set1 & node_set2
-        assert_equal node_set1.document, new_set.document
-        assert new_set.respond_to?(:awesome!)
-      end
-
-      def test_node_set_difference_result_has_document_and_is_decorated
-        x = Module.new do
-          def awesome! ; end
-        end
-        util_decorate(@xml, x)
-        node_set1 = @xml.css("address")
-        node_set2 = @xml.css("address")
-        new_set  = node_set1 - node_set2
-        assert_equal node_set1.document, new_set.document
-        assert new_set.respond_to?(:awesome!)
-      end
-
-      def test_node_set_slice_result_has_document_and_is_decorated
-        x = Module.new do
-          def awesome! ; end
-        end
-        util_decorate(@xml, x)
-        node_set = @xml.css("address")
-        new_set  = node_set[0..-1]
-        assert_equal node_set.document, new_set.document
-        assert new_set.respond_to?(:awesome!)
-      end
-    end
-  end
-end