nokogiri 1.4.1-java → 1.4.2-java

data/test/test_reader.rb

@@ -332,6 +332,34 @@ class TestReader < Nokogiri::TestCase
                  reader.map { |n| n.name })
   end
 
+  def test_base_uri
+    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
+      <x xml:base="http://base.example.org/base/">
+        <link href="link"/>
+        <other xml:base="http://other.example.org/"/>
+        <relative xml:base="relative">
+          <link href="stuff" />
+        </relative>
+      </x>
+    eoxml
+
+    assert_nil reader.base_uri
+    assert_equal(["http://base.example.org/base/",
+                  "http://base.example.org/base/",
+                  "http://base.example.org/base/",
+                  "http://base.example.org/base/",
+                  "http://other.example.org/",
+                  "http://base.example.org/base/",
+                  "http://base.example.org/base/relative",
+                  "http://base.example.org/base/relative",
+                  "http://base.example.org/base/relative",
+                  "http://base.example.org/base/relative",
+                  "http://base.example.org/base/relative",
+                  "http://base.example.org/base/",
+                  "http://base.example.org/base/"],
+                  reader.map {|n| n.base_uri })
+  end
+
   def test_read_from_memory
     called = false
     reader = Nokogiri::XML::Reader.from_memory('<foo>bar</foo>')

data/test/test_xslt_transforms.rb

@@ -70,6 +70,20 @@ encoding="iso-8859-1" indent="yes"/>
       assert_no_match(/<td>/, xslt.apply_to(@doc, ['title', 'foo']))
     end
 
+    def test_transform_arg_error
+      assert style = Nokogiri::XSLT(File.read(XSLT_FILE))
+      assert_raises(TypeError) do
+        style.transform(@doc, :foo)
+      end
+    end
+
+    def test_transform_with_hash
+      assert style = Nokogiri::XSLT(File.read(XSLT_FILE))
+      result = style.transform(@doc, {'title' => '"Booyah"'})
+      assert result.html?
+      assert_equal "Booyah", result.at_css("h1").content
+    end
+
     def test_transform2
       assert style = Nokogiri::XSLT(File.open(XSLT_FILE))
       assert result_doc = style.transform(@doc)

data/test/xml/test_builder.rb

@@ -3,6 +3,43 @@ require "helper"
 module Nokogiri
   module XML
     class TestBuilder < Nokogiri::TestCase
+      def test_builder_namespace
+        doc = Nokogiri::XML::Builder.new { |xml|
+          xml.a("xmlns:a" => "x") do
+            xml.b("xmlns:a" => "x", "xmlns:b" => "y")
+          end
+        }.doc
+
+        b = doc.at('b')
+        assert b
+        assert_equal({"xmlns:a"=>"x", "xmlns:b"=>"y"}, b.namespaces)
+        assert_equal({"xmlns:b"=>"y"}, namespaces_defined_on(b))
+      end
+
+      def test_builder_namespace_part_deux
+        doc = Nokogiri::XML::Builder.new { |xml|
+          xml.a("xmlns:b" => "y") do
+            xml.b("xmlns:a" => "x", "xmlns:b" => "y", "xmlns:c" => "z")
+          end
+        }.doc
+
+        b = doc.at('b')
+        assert b
+        assert_equal({"xmlns:a"=>"x", "xmlns:b"=>"y", "xmlns:c"=>"z"}, b.namespaces)
+        assert_equal({"xmlns:a"=>"x", "xmlns:c"=>"z"}, namespaces_defined_on(b))
+      end
+
+      def test_builder_with_unlink
+        assert_nothing_raised do
+          Nokogiri::XML::Builder.new do |xml|
+            xml.foo do
+              xml.bar { xml.parent.unlink }
+              xml.bar2
+            end
+          end
+        end
+      end
+
       def test_with_root
         doc = Nokogiri::XML(File.read(XML_FILE))
         Nokogiri::XML::Builder.with(doc.at('employee')) do |xml|
@@ -162,6 +199,12 @@ module Nokogiri
         }
         assert_equal("<?xml version=\"1.0\"?><root><![CDATA[hello world]]></root>", builder.to_xml.gsub(/\n/, ''))
       end
+
+    private
+
+      def namespaces_defined_on(node)
+        Hash[*node.namespace_definitions.collect{|n| ["xmlns:" + n.prefix, n.href]}.flatten]
+      end
     end
   end
 end

data/test/xml/test_cdata.rb

@@ -33,6 +33,18 @@ module Nokogiri
           node = CDATA.new(@xml, "asdfasdf")
         }
       end
+
+      def test_content=
+        node = CDATA.new(@xml, 'foo')
+        assert_equal('foo', node.content)
+
+        node.content = '& <foo> &amp;'
+        assert_equal('& <foo> &amp;', node.content)
+        assert_equal('<![CDATA[& <foo> &amp;]]>', node.to_xml)
+
+        node.content = 'foo ]]> bar'
+        assert_equal('foo ]]> bar', node.content)
+      end
     end
   end
 end

data/test/xml/test_document.rb

@@ -5,11 +5,28 @@ require 'uri'
 module Nokogiri
   module XML
     class TestDocument < Nokogiri::TestCase
+      URI = if URI.const_defined?(:DEFAULT_PARSER)
+              ::URI::DEFAULT_PARSER
+            else
+              ::URI
+            end
+
       def setup
         super
         @xml = Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE)
       end
 
+      def test_root_set_to_nil
+        @xml.root = nil
+        assert_equal nil, @xml.root
+      end
+
+      def test_parse_should_not_exist
+        assert_raises(NoMethodError) do
+          @xml.parse("foo")
+        end
+      end
+
       def test_collect_namespaces
         doc = Nokogiri::XML(<<-eoxml)
         <xml>
@@ -47,6 +64,29 @@ module Nokogiri
         assert_equal @xml, elm.document
       end
 
+      def test_create_element_with_attributes
+        elm = @xml.create_element('foo',:a => "1")
+        assert_instance_of Nokogiri::XML::Element, elm
+        assert_instance_of Nokogiri::XML::Attr, elm.attributes["a"]
+        assert_equal "1", elm["a"]
+      end
+
+      def test_create_element_with_namespace
+        elm = @xml.create_element('foo',:'xmlns:foo' => 'http://tenderlovemaking.com')
+        assert_equal 'http://tenderlovemaking.com', elm.namespaces['xmlns:foo']
+      end
+
+      def test_create_element_with_content
+        elm = @xml.create_element('foo',"needs more xml/violence")
+        assert_equal "needs more xml/violence", elm.content
+      end
+
+      def test_create_cdata
+        cdata = @xml.create_cdata("abc")
+        assert_instance_of Nokogiri::XML::CDATA, cdata
+        assert_equal "abc", cdata.content
+      end
+
       def test_pp
         out = StringIO.new('')
         assert_nothing_raised do
@@ -467,21 +507,21 @@ module Nokogiri
 
         ctx = Nokogiri::XML::XPathContext.new(doc)
         ctx.register_ns 'tenderlove', 'http://tenderlovemaking.com/'
-        set = ctx.evaluate('//tenderlove:foo').node_set
+        set = ctx.evaluate('//tenderlove:foo')
         assert_equal 1, set.length
         assert_equal 'foo', set.first.name
 
         # It looks like only the URI is important:
         ctx = Nokogiri::XML::XPathContext.new(doc)
         ctx.register_ns 'america', 'http://tenderlovemaking.com/'
-        set = ctx.evaluate('//america:foo').node_set
+        set = ctx.evaluate('//america:foo')
         assert_equal 1, set.length
         assert_equal 'foo', set.first.name
 
         # Its so important that a missing slash will cause it to return nothing
         ctx = Nokogiri::XML::XPathContext.new(doc)
         ctx.register_ns 'america', 'http://tenderlovemaking.com'
-        set = ctx.evaluate('//america:foo').node_set
+        set = ctx.evaluate('//america:foo')
         assert_equal 0, set.length
       end
 
@@ -540,38 +580,6 @@ module Nokogiri
         assert dup.xml?, 'duplicate should be xml'
       end
 
-      def test_subset_is_decorated
-        x = Module.new do
-          def awesome!
-          end
-        end
-        util_decorate(@xml, x)
-
-        assert @xml.respond_to?(:awesome!)
-        assert node_set = @xml.search('//staff')
-        assert node_set.respond_to?(:awesome!)
-        assert subset = node_set.search('.//employee')
-        assert subset.respond_to?(:awesome!)
-        assert sub_subset = node_set.search('.//name')
-        assert sub_subset.respond_to?(:awesome!)
-      end
-
-      def test_decorator_is_applied
-        x = Module.new do
-          def awesome!
-          end
-        end
-        util_decorate(@xml, x)
-
-        assert @xml.respond_to?(:awesome!)
-        assert node_set = @xml.search('//employee')
-        assert node_set.respond_to?(:awesome!)
-        node_set.each do |node|
-          assert node.respond_to?(:awesome!), node.class
-        end
-        assert @xml.root.respond_to?(:awesome!)
-      end
-
       def test_new
         doc = nil
         assert_nothing_raised {
@@ -623,10 +631,37 @@ module Nokogiri
         assert_equal 0, doc.xpath("//x:foo", "x" => "http://c.flavorjon.es/").length
       end
 
-      def util_decorate(document, x)
-        document.decorators(XML::Node) << x
-        document.decorators(XML::NodeSet) << x
-        document.decorate!
+      def test_subset_is_decorated
+        x = Module.new do
+          def awesome!
+          end
+        end
+        util_decorate(@xml, x)
+
+        assert @xml.respond_to?(:awesome!)
+        assert node_set = @xml.search('//staff')
+        assert node_set.respond_to?(:awesome!)
+        assert subset = node_set.search('.//employee')
+        assert subset.respond_to?(:awesome!)
+        assert sub_subset = node_set.search('.//name')
+        assert sub_subset.respond_to?(:awesome!)
+      end
+
+      def test_decorator_is_applied
+        x = Module.new do
+          def awesome!
+          end
+        end
+        util_decorate(@xml, x)
+
+        assert @xml.respond_to?(:awesome!)
+        assert node_set = @xml.search('//employee')
+        assert node_set.respond_to?(:awesome!)
+        node_set.each do |node|
+          assert node.respond_to?(:awesome!), node.class
+        end
+        assert @xml.root.respond_to?(:awesome!)
+        assert @xml.children.respond_to?(:awesome!)
       end
     end
   end

data/test/xml/test_document_fragment.rb

@@ -8,6 +8,26 @@ module Nokogiri
         @xml = Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE)
       end
 
+      def test_fragment_is_relative
+        doc      = Nokogiri::XML('<root><a xmlns="blah" /></root>')
+        ctx      = doc.root.child
+        fragment = Nokogiri::XML::DocumentFragment.new(doc, '<hello />', ctx)
+        hello    = fragment.child
+
+        assert_equal 'hello', hello.name
+        assert_equal doc.root.child.namespace, hello.namespace
+      end
+
+      def test_node_fragment_is_relative
+        doc      = Nokogiri::XML('<root><a xmlns="blah" /></root>')
+        ctx      = doc.root.child
+        fragment = doc.root.child.fragment('<hello />')
+        hello    = fragment.child
+
+        assert_equal 'hello', hello.name
+        assert_equal doc.root.child.namespace, hello.namespace
+      end
+
       def test_new
         fragment = Nokogiri::XML::DocumentFragment.new(@xml)
       end
@@ -139,6 +159,22 @@ module Nokogiri
         frag = doc.fragment "<baz:newnode></baz:newnode>"
         assert_nil frag.children.first.namespace
       end
+
+      def test_decorator_is_applied
+        x = Module.new do
+          def awesome!
+          end
+        end
+        util_decorate(@xml, x)
+        fragment = Nokogiri::XML::DocumentFragment.new(@xml, "<div>a</div><div>b</div>")
+
+        assert node_set = fragment.css('div')
+        assert node_set.respond_to?(:awesome!)
+        node_set.each do |node|
+          assert node.respond_to?(:awesome!), node.class
+        end
+        assert fragment.children.respond_to?(:awesome!), fragment.children.class
+      end
     end
   end
 end

data/test/xml/test_entity_decl.rb

@@ -18,6 +18,43 @@ module Nokogiri
         @entity_decl = @entities.first
       end
 
+      def test_constants # for libffi implementation. *sigh* sorry Mike. :-(
+        assert_equal 1, EntityDecl::INTERNAL_GENERAL
+        assert_equal 2, EntityDecl::EXTERNAL_GENERAL_PARSED
+        assert_equal 3, EntityDecl::EXTERNAL_GENERAL_UNPARSED
+        assert_equal 4, EntityDecl::INTERNAL_PARAMETER
+        assert_equal 5, EntityDecl::EXTERNAL_PARAMETER
+        assert_equal 6, EntityDecl::INTERNAL_PREDEFINED
+
+        # While I'm here, another problem with libffi comes to mind.  If someone
+        # upgrades their version of any particular C library, and the constants
+        # change values, the client using Ruby code is fucked.  That sucks.
+        # Basically anything to do with the preprocessor fucks someone using
+        # libffi.  :-(
+      end
+
+      def test_create_typed_entity
+        entity = @xml.create_entity(
+          'foo', EntityDecl::INTERNAL_GENERAL, nil, nil, nil
+        )
+        assert_equal EntityDecl::INTERNAL_GENERAL, entity.entity_type
+        assert_equal 'foo', entity.name
+      end
+
+      def test_new
+        entity = Nokogiri::XML::EntityDecl.new(
+          'foo', @xml, EntityDecl::INTERNAL_GENERAL, nil, nil, nil
+        )
+        assert_equal EntityDecl::INTERNAL_GENERAL, entity.entity_type
+        assert_equal 'foo', entity.name
+      end
+
+      def test_create_default_args
+        entity = @xml.create_entity('foo')
+        assert_equal EntityDecl::INTERNAL_GENERAL, entity.entity_type
+        assert_equal 'foo', entity.name
+      end
+
       def test_external_id
         assert_nil @entity_decl.external_id
       end

data/test/xml/test_node.rb

@@ -10,6 +10,99 @@ module Nokogiri
         @xml = Nokogiri::XML(File.read(XML_FILE), XML_FILE)
       end
 
+      def test_first_element_child
+        node = @xml.root.first_element_child
+        assert_equal 'employee', node.name
+        assert node.element?, 'node is an element'
+      end
+
+      def test_element_children
+        nodes = @xml.root.element_children
+        assert_equal @xml.root.first_element_child, nodes.first
+        assert nodes.all? { |node| node.element? }, 'all nodes are elements'
+      end
+
+      def test_last_element_child
+        nodes = @xml.root.element_children
+        assert_equal nodes.last, @xml.root.element_children.last
+      end
+
+      def test_bad_xpath
+        bad_xpath = '//foo['
+
+        begin
+          @xml.xpath(bad_xpath)
+        rescue Nokogiri::XML::XPath::SyntaxError => e
+          assert_match(bad_xpath, e.to_s)
+        end
+      end
+
+      def test_namespace_type_error
+        assert_raises(TypeError) do
+          @xml.root.namespace = Object.new
+        end
+      end
+
+      def test_remove_namespace
+        @xml = Nokogiri::XML('<r xmlns="v"><s /></r>')
+        tag = @xml.at('s')
+        assert tag.namespace
+        tag.namespace = nil
+        assert_nil tag.namespace
+      end
+
+      def test_parse_needs_doc
+        list = @xml.root.parse('fooooooo <hello />')
+        assert_equal 1, list.css('hello').length
+      end
+
+      def test_parse
+        list = @xml.root.parse('fooooooo <hello />')
+        assert_equal 2, list.length
+      end
+
+      def test_parse_with_block
+        called = false
+        list = @xml.root.parse('<hello />') { |cfg|
+          called = true
+          assert_instance_of Nokogiri::XML::ParseOptions, cfg
+        }
+        assert called, 'config block called'
+        assert_equal 1, list.length
+      end
+
+      def test_parse_with_io
+        list = @xml.root.parse(StringIO.new('<hello />'))
+        assert_equal 1, list.length
+        assert_equal 'hello', list.first.name
+      end
+
+      def test_parse_with_empty_string
+        list = @xml.root.parse('')
+        assert_equal 0, list.length
+      end
+
+      # descriptive, not prescriptive.
+      def test_parse_invalid_html_markup_results_in_empty_nodeset
+        doc = Nokogiri::HTML("<html></html>")
+        nodeset = doc.root.parse "<div><div>a</div><snippet>b</snippet></div>"
+        assert_equal 1, doc.errors.length # "Tag snippet invalid"
+        assert_equal 0, nodeset.length
+      end
+
+      def test_parse_error_list
+        error_count = @xml.errors.length
+        list = @xml.root.parse('<hello>')
+        assert_equal 0, list.length
+        assert(error_count < @xml.errors.length, "errors should have increased")
+      end
+
+      def test_subclass_dup
+        subclass = Class.new(Nokogiri::XML::Node)
+        node = subclass.new('foo', @xml).dup
+        assert_instance_of subclass, node
+      end
+
       def test_gt_string_arg
         node = @xml.at('employee')
         nodes = (node > 'name')
@@ -111,32 +204,24 @@ module Nokogiri
         end
       end
 
-      def test_namespace_nodes
+      def test_namespace_definitions_when_some_exist
         xml = Nokogiri::XML <<-eoxml
           <root xmlns="http://tenderlovemaking.com/" xmlns:foo="bar">
             <awesome/>
           </root>
         eoxml
-        awesome = xml.root
-        namespaces = awesome.namespace_definitions
-        assert_equal 2, namespaces.length
+        namespace_definitions = xml.root.namespace_definitions
+        assert_equal 2, namespace_definitions.length
       end
 
-      def test_no_definitions
+      def test_namespace_definitions_when_no_exist
         xml = Nokogiri::XML <<-eoxml
           <root xmlns="http://tenderlovemaking.com/" xmlns:foo="bar">
             <awesome/>
           </root>
         eoxml
-        awesome = xml.at('//xmlns:awesome')
-        namespaces = awesome.namespace_definitions
-        assert_equal 0, namespaces.length
-      end
-
-      def test_subclass_dup
-        subclass = Class.new(Nokogiri::XML::Node)
-        node = subclass.new('foo', @xml).dup
-        assert_instance_of subclass, node
+        namespace_definitions = xml.at_xpath('//xmlns:awesome').namespace_definitions
+        assert_equal 0, namespace_definitions.length
       end
 
       def test_namespace_goes_to_children
@@ -607,6 +692,17 @@ module Nokogiri
 
         node.content = 'hello world!'
         assert_equal('hello world!', node.content)
+
+        node.content = '& <foo> &amp;'
+        assert_equal('& <foo> &amp;', node.content)
+        assert_equal('<form>&amp; &lt;foo&gt; &amp;amp;</form>', node.to_xml)
+      end
+
+      def test_set_content_should_unlink_existing_content
+        node     = @xml.at_css("employee")
+        children = node.children
+        node.content = "hello"
+        children.each { |child| assert_nil child.parent }
       end
 
       def test_whitespace_nodes
@@ -629,16 +725,16 @@ module Nokogiri
         assert_equal address1_1, address1_2 # two references to the exact same node
       end
 
-      def test_namespace_as_hash
+      def test_namespace_search_with_xpath_and_hash
         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>
+        <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
 
         tires = xml.xpath('//bike:tire', {'bike' => 'http://schwinn.com/'})
@@ -647,58 +743,70 @@ module Nokogiri
 
       def test_namespace_search_with_css
         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>
+        <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
 
         tires = xml.css('bike|tire', 'bike' => 'http://schwinn.com/')
         assert_equal 1, tires.length
       end
 
-      def test_namespaces
+      def test_namespaces_should_include_all_namespace_definitions
         xml = Nokogiri::XML.parse(<<-EOF)
-<x xmlns:a='http://foo.com/' xmlns:b='http://bar.com/'>
-  <y xmlns:c='http://bazz.com/'>
-    <a:div>hello a</a:div>
-    <b:div>hello b</b:div>
-    <c:div>hello c</c:div>
-  </y>  
-</x>
-EOF
-        assert namespaces = xml.root.namespaces
-        assert namespaces.key?('xmlns:a')
-        assert_equal 'http://foo.com/', namespaces['xmlns:a']
-        assert namespaces.key?('xmlns:b')
-        assert_equal 'http://bar.com/', namespaces['xmlns:b']
-        assert ! namespaces.key?('xmlns:c')
-
-        assert namespaces = xml.namespaces
-        assert namespaces.key?('xmlns:a')
-        assert_equal 'http://foo.com/', namespaces['xmlns:a']
-        assert namespaces.key?('xmlns:b')
-        assert_equal 'http://bar.com/', namespaces['xmlns:b']
-
-        assert_equal "hello a", xml.search("//a:div", xml.namespaces).first.inner_text
-        assert_equal "hello b", xml.search("//b:div", xml.namespaces).first.inner_text
+        <x xmlns="http://quux.com/" xmlns:a="http://foo.com/" xmlns:b="http://bar.com/">
+          <y xmlns:c="http://bazz.com/">
+            <z>hello</z>
+            <a xmlns:c="http://newc.com/" />
+          </y>
+        </x>
+        EOF
+
+        namespaces = xml.namespaces # Document#namespace
+        assert_equal({"xmlns"   => "http://quux.com/",
+                      "xmlns:a" => "http://foo.com/",
+                      "xmlns:b" => "http://bar.com/"}, namespaces)
+
+        namespaces = xml.root.namespaces
+        assert_equal({"xmlns"   => "http://quux.com/",
+                      "xmlns:a" => "http://foo.com/",
+                      "xmlns:b" => "http://bar.com/"}, namespaces)
+
+        namespaces = xml.at_xpath("//xmlns:y").namespaces
+        assert_equal({"xmlns"   => "http://quux.com/",
+                      "xmlns:a" => "http://foo.com/",
+                      "xmlns:b" => "http://bar.com/",
+                      "xmlns:c" => "http://bazz.com/"}, namespaces)
+
+        namespaces = xml.at_xpath("//xmlns:z").namespaces
+        assert_equal({"xmlns"   => "http://quux.com/",
+                      "xmlns:a" => "http://foo.com/",
+                      "xmlns:b" => "http://bar.com/",
+                      "xmlns:c" => "http://bazz.com/"}, namespaces)
+
+        namespaces = xml.at_xpath("//xmlns:a").namespaces
+        assert_equal({"xmlns"   => "http://quux.com/",
+                      "xmlns:a" => "http://foo.com/",
+                      "xmlns:b" => "http://bar.com/",
+                      "xmlns:c" => "http://newc.com/"}, namespaces)
       end
 
       def test_namespace
         xml = Nokogiri::XML.parse(<<-EOF)
-<x xmlns:a='http://foo.com/' xmlns:b='http://bar.com/'>
-  <y xmlns:c='http://bazz.com/'>
-    <a:div>hello a</a:div>
-    <b:div>hello b</b:div>
-    <c:div>hello c</c:div>
-    <div>hello moon</div>
-  </y>  
-</x>
-EOF
+        <x xmlns:a='http://foo.com/' xmlns:b='http://bar.com/'>
+          <y xmlns:c='http://bazz.com/'>
+            <a:div>hello a</a:div>
+            <b:div>hello b</b:div>
+            <c:div>hello c</c:div>
+            <div>hello moon</div>
+          </y>  
+        </x>
+        EOF
         set = xml.search("//y/*")
         assert_equal "a", set[0].namespace.prefix
         assert_equal "b", set[1].namespace.prefix
@@ -709,7 +817,7 @@ EOF
       def test_namespace_without_an_href_on_html_node
         # because microsoft word's HTML formatting does this. ick.
         xml = Nokogiri::HTML.parse <<-EOF
-<div><o:p>foo</o:p></div>
+          <div><o:p>foo</o:p></div>
         EOF
 
         assert_not_nil(node = xml.at('p'))
@@ -733,6 +841,25 @@ EOF
         assert_equal 2, node.line
       end
 
+      def test_xpath_results_have_document_and_are_decorated
+        x = Module.new do
+          def awesome! ; end
+        end
+        util_decorate(@xml, x)
+        node_set = @xml.xpath("//employee")
+        assert_equal @xml, node_set.document
+        assert node_set.respond_to?(:awesome!)
+      end
+
+      def test_css_results_have_document_and_are_decorated
+        x = Module.new do
+          def awesome! ; end
+        end
+        util_decorate(@xml, x)
+        node_set = @xml.css("employee")
+        assert_equal @xml, node_set.document
+        assert node_set.respond_to?(:awesome!)
+      end
     end
   end
 end