RubyGems - vtd_xml - Versions diffs - 0.0.3-java → 0.0.6-java - Mend

vtd_xml 0.0.3-java → 0.0.6-java

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (536) hide show

data/bundle/jruby/1.9/gems/nokogiri-1.6.1-java/test/html/test_document_fragment.rb DELETED Viewed

@@ -1,261 +0,0 @@
-# -*- coding: utf-8 -*-
-require "helper"
-module Nokogiri
-  module HTML
-    class TestDocumentFragment < Nokogiri::TestCase
-      def setup
-        super
-        @html = Nokogiri::HTML.parse(File.read(HTML_FILE), HTML_FILE)
-      end
-      if RUBY_VERSION >= '1.9'
-        def test_inspect_encoding
-          fragment = "<div>こんにちは！</div>".encode('EUC-JP')
-          f = Nokogiri::HTML::DocumentFragment.parse fragment
-          assert_equal "こんにちは！", f.content
-        end
-        def test_html_parse_encoding
-          fragment = "<div>こんにちは！</div>".encode 'EUC-JP'
-          f = Nokogiri::HTML.fragment fragment
-          assert_equal 'EUC-JP', f.document.encoding
-          assert_equal "こんにちは！", f.content
-        end
-      end
-      def test_colons_are_not_removed
-        doc = Nokogiri::HTML::DocumentFragment.parse("<span>3:30pm</span>")
-        assert_match(/3:30/, doc.to_s)
-      end
-      def test_parse_encoding
-        fragment = "<div>hello world</div>"
-        f = Nokogiri::HTML::DocumentFragment.parse fragment, 'ISO-8859-1'
-        assert_equal 'ISO-8859-1', f.document.encoding
-        assert_equal "hello world", f.content
-      end
-      def test_html_parse_with_encoding
-        fragment = "<div>hello world</div>"
-        f = Nokogiri::HTML.fragment fragment, 'ISO-8859-1'
-        assert_equal 'ISO-8859-1', f.document.encoding
-        assert_equal "hello world", f.content
-      end
-      def test_parse_in_context
-        assert_equal('<br>', @html.root.parse('<br />').to_s)
-      end
-      def test_inner_html=
-        fragment = Nokogiri::HTML.fragment '<hr />'
-        fragment.inner_html = "hello"
-        assert_equal 'hello', fragment.inner_html
-      end
-      def test_ancestors_search
-        html = %q{
-          <div>
-            <ul>
-              <li>foo</li>
-            </ul>
-          </div>
-        }
-        fragment = Nokogiri::HTML.fragment html
-        li = fragment.at('li')
-        assert li.matches?('li')
-      end
-      def test_fun_encoding
-        string = %Q(<body>こんにちは</body>)
-        html = Nokogiri::HTML::DocumentFragment.parse(
-          string
-        ).to_html(:encoding => 'UTF-8')
-        assert_equal string, html
-      end
-      def test_new
-        assert Nokogiri::HTML::DocumentFragment.new(@html)
-      end
-      def test_body_fragment_should_contain_body
-        fragment = Nokogiri::HTML::DocumentFragment.parse("  <body><div>foo</div></body>")
-        assert_match(/^<body>/, fragment.to_s)
-      end
-      def test_nonbody_fragment_should_not_contain_body
-        fragment = Nokogiri::HTML::DocumentFragment.parse("<div>foo</div>")
-        assert_match(/^<div>/, fragment.to_s)
-      end
-      def test_fragment_should_have_document
-        fragment = Nokogiri::HTML::DocumentFragment.new(@html)
-        assert_equal @html, fragment.document
-      end
-      def test_empty_fragment_should_be_searchable_by_css
-        fragment = Nokogiri::HTML.fragment("")
-        assert_equal 0, fragment.css("a").size
-      end
-      def test_empty_fragment_should_be_searchable
-        fragment = Nokogiri::HTML.fragment("")
-        assert_equal 0, fragment.search("//a").size
-      end
-      def test_name
-        fragment = Nokogiri::HTML::DocumentFragment.new(@html)
-        assert_equal '#document-fragment', fragment.name
-      end
-      def test_static_method
-        fragment = Nokogiri::HTML::DocumentFragment.parse("<div>a</div>")
-        assert_instance_of Nokogiri::HTML::DocumentFragment, fragment
-      end
-      def test_many_fragments
-        100.times { Nokogiri::HTML::DocumentFragment.new(@html) }
-      end
-      def test_subclass
-        klass = Class.new(Nokogiri::HTML::DocumentFragment)
-        fragment = klass.new(@html, "<div>a</div>")
-        assert_instance_of klass, fragment
-      end
-      def test_subclass_parse
-        klass = Class.new(Nokogiri::HTML::DocumentFragment)
-        doc = klass.parse("<div>a</div>")
-        assert_instance_of klass, doc
-      end
-      def test_html_fragment
-        fragment = Nokogiri::HTML.fragment("<div>a</div>")
-        assert_equal "<div>a</div>", fragment.to_s
-      end
-      def test_html_fragment_has_outer_text
-        doc = "a<div>b</div>c"
-        fragment = Nokogiri::HTML::Document.new.fragment(doc)
-        if Nokogiri.uses_libxml? &&
-            Nokogiri::VERSION_INFO['libxml']['loaded'] <= "2.6.16"
-          assert_equal "a<div>b</div><p>c</p>", fragment.to_s
-        else
-          assert_equal "a<div>b</div>c", fragment.to_s
-        end
-      end
-      def test_html_fragment_case_insensitivity
-        doc = "<Div>b</Div>"
-        fragment = Nokogiri::HTML::Document.new.fragment(doc)
-        assert_equal "<div>b</div>", fragment.to_s
-      end
-      def test_html_fragment_with_leading_whitespace
-        doc = "     <div>b</div>  "
-        fragment = Nokogiri::HTML::Document.new.fragment(doc)
-        assert_match %r%     <div>b</div> *%, fragment.to_s
-      end
-      def test_html_fragment_with_leading_whitespace_and_newline
-        doc = "     \n<div>b</div>  "
-        fragment = Nokogiri::HTML::Document.new.fragment(doc)
-        assert_match %r%     \n<div>b</div> *%, fragment.to_s
-      end
-      def test_html_fragment_with_leading_text_and_newline
-        fragment = HTML::Document.new.fragment("First line\nSecond line<br>Broken line")
-        assert_equal fragment.to_s, "First line\nSecond line<br>Broken line"
-      end
-      def test_html_fragment_with_leading_whitespace_and_text_and_newline
-        fragment = HTML::Document.new.fragment("  First line\nSecond line<br>Broken line")
-        assert_equal "  First line\nSecond line<br>Broken line", fragment.to_s
-      end
-      def test_html_fragment_with_leading_entity
-        failed = "&quot;test<br/>test&quot;"
-        fragment = Nokogiri::HTML::DocumentFragment.parse(failed)
-        assert_equal '"test<br>test"', fragment.to_html
-      end
-      def test_to_s
-        doc = "<span>foo<br></span><span>bar</span>"
-        fragment = Nokogiri::HTML::Document.new.fragment(doc)
-        assert_equal "<span>foo<br></span><span>bar</span>", fragment.to_s
-      end
-      def test_to_html
-        doc = "<span>foo<br></span><span>bar</span>"
-        fragment = Nokogiri::HTML::Document.new.fragment(doc)
-        assert_equal "<span>foo<br></span><span>bar</span>", fragment.to_html
-      end
-      def test_to_xhtml
-        doc = "<span>foo<br></span><span>bar</span>"
-        fragment = Nokogiri::HTML::Document.new.fragment(doc)
-        if Nokogiri.jruby? || Nokogiri::VERSION_INFO['libxml']['loaded'] >= "2.7.0"
-          assert_equal "<span>foo<br /></span><span>bar</span>", fragment.to_xhtml
-        else
-          # FIXME: why are we doing this ? this violates the spec,
-          # see http://www.w3.org/TR/xhtml1/#C_2
-          assert_equal "<span>foo<br></span><span>bar</span>", fragment.to_xhtml
-        end
-      end
-      def test_to_xml
-        doc = "<span>foo<br></span><span>bar</span>"
-        fragment = Nokogiri::HTML::Document.new.fragment(doc)
-        assert_equal "<span>foo<br/></span><span>bar</span>", fragment.to_xml
-      end
-      def test_fragment_script_tag_with_cdata
-        doc = HTML::Document.new
-        fragment = doc.fragment("<script>var foo = 'bar';</script>")
-        assert_equal("<script>var foo = 'bar';</script>",
-          fragment.to_s)
-      end
-      def test_fragment_with_comment
-        doc = HTML::Document.new
-        fragment = doc.fragment("<p>hello<!-- your ad here --></p>")
-        assert_equal("<p>hello<!-- your ad here --></p>",
-          fragment.to_s)
-      end
-      def test_malformed_fragment_is_corrected
-        fragment = HTML::DocumentFragment.parse("<div </div>")
-        assert_equal "<div></div>", fragment.to_s
-      end
-      def test_unclosed_script_tag
-        # see GH#315
-        fragment = HTML::DocumentFragment.parse("foo <script>bar")
-        assert_equal "foo <script>bar</script>", fragment.to_html
-      end
-      def test_error_propagation_on_fragment_parse
-        frag = Nokogiri::HTML::DocumentFragment.parse "<hello>oh, hello there.</hello>"
-        assert frag.errors.any?{|err| err.to_s =~ /Tag hello invalid/}, "errors should be copied to the fragment"
-      end
-      def test_error_propagation_on_fragment_parse_in_node_context
-        doc = Nokogiri::HTML::Document.parse "<html><body><div></div></body></html>"
-        context_node = doc.at_css "div"
-        frag = Nokogiri::HTML::DocumentFragment.new doc, "<hello>oh, hello there.</hello>", context_node
-        assert frag.errors.any?{|err| err.to_s =~ /Tag hello invalid/}, "errors should be on the context node's document"
-      end
-      def test_error_propagation_on_fragment_parse_in_node_context_should_not_include_preexisting_errors
-        doc = Nokogiri::HTML::Document.parse "<html><body><div></div><jimmy></jimmy></body></html>"
-        assert doc.errors.any?{|err| err.to_s =~ /jimmy/}, "assert on setup"
-        context_node = doc.at_css "div"
-        frag = Nokogiri::HTML::DocumentFragment.new doc, "<hello>oh, hello there.</hello>", context_node
-        assert frag.errors.any?{|err| err.to_s =~ /Tag hello invalid/}, "errors should be on the context node's document"
-        assert frag.errors.none?{|err| err.to_s =~ /jimmy/}, "errors should not include pre-existing document errors"
-      end
-    end
-  end
-end

data/bundle/jruby/1.9/gems/nokogiri-1.6.1-java/test/html/test_element_description.rb DELETED Viewed

@@ -1,105 +0,0 @@
-require "helper"
-module Nokogiri
-  module HTML
-    class TestElementDescription < Nokogiri::TestCase
-      def test_fetch_nonexistent
-        assert_nil ElementDescription['foo']
-      end
-      def test_fetch_element_description
-        assert desc = ElementDescription['a']
-        assert_instance_of ElementDescription, desc
-      end
-      def test_name
-        assert_equal 'a', ElementDescription['a'].name
-      end
-      def test_implied_start_tag?
-        assert !ElementDescription['a'].implied_start_tag?
-      end
-      def test_implied_end_tag?
-        assert !ElementDescription['a'].implied_end_tag?
-        assert ElementDescription['p'].implied_end_tag?
-      end
-      def test_save_end_tag?
-        assert !ElementDescription['a'].save_end_tag?
-        assert ElementDescription['br'].save_end_tag?
-      end
-      def test_empty?
-        assert ElementDescription['br'].empty?
-        assert !ElementDescription['a'].empty?
-      end
-      def test_deprecated?
-        assert ElementDescription['applet'].deprecated?
-        assert !ElementDescription['br'].deprecated?
-      end
-      def test_inline?
-        assert ElementDescription['a'].inline?
-        assert !ElementDescription['div'].inline?
-      end
-      def test_block?
-        element = ElementDescription['a']
-        assert_equal(!element.inline?, element.block?)
-      end
-      def test_description
-        assert ElementDescription['a'].description
-      end
-      def test_subelements
-        sub_elements = ElementDescription['body'].sub_elements
-        if Nokogiri.uses_libxml? && Nokogiri::LIBXML_VERSION >= '2.7.7'
-          assert_equal 65, sub_elements.length
-        elsif Nokogiri.uses_libxml?
-          assert_equal 61, sub_elements.length
-        else
-          assert sub_elements.length > 0
-        end
-      end
-      def test_default_sub_element
-        assert_equal 'div', ElementDescription['body'].default_sub_element
-      end
-      def test_null_default_sub_element
-        doc = Nokogiri::HTML('foo')
-        doc.root.description.default_sub_element
-      end
-      def test_optional_attributes
-        attrs = ElementDescription['table'].optional_attributes
-        assert attrs
-      end
-      def test_deprecated_attributes
-        attrs = ElementDescription['table'].deprecated_attributes
-        assert attrs
-        assert_equal 2, attrs.length
-      end
-      def test_required_attributes
-        attrs = ElementDescription['table'].required_attributes
-        assert attrs
-        assert_equal 0, attrs.length
-      end
-      def test_inspect
-        desc = ElementDescription['input']
-        assert_match desc.name, desc.inspect
-      end
-      def test_to_s
-        desc = ElementDescription['input']
-        assert_match desc.name, desc.to_s
-      end
-    end
-  end
-end

data/bundle/jruby/1.9/gems/nokogiri-1.6.1-java/test/html/test_named_characters.rb DELETED Viewed

@@ -1,14 +0,0 @@
-require "helper"
-module Nokogiri
-  module HTML
-    class TestNamedCharacters < Nokogiri::TestCase
-      def test_named_character
-        copy = NamedCharacters.get('copy')
-        assert_equal 169, NamedCharacters['copy']
-        assert_equal copy.value, NamedCharacters['copy']
-        assert copy.description
-      end
-    end
-  end
-end

data/bundle/jruby/1.9/gems/nokogiri-1.6.1-java/test/html/test_node.rb DELETED Viewed

@@ -1,196 +0,0 @@
-require "helper"
-require 'nkf'
-module Nokogiri
-  module HTML
-    class TestNode < Nokogiri::TestCase
-      def setup
-        super
-        @html = Nokogiri::HTML(<<-eohtml)
-        <html>
-          <head></head>
-          <body>
-            <div class='baz'><a href="foo" class="bar">first</a></div>
-          </body>
-        </html>
-        eohtml
-      end
-      def test_to_a
-        assert_equal [['class', 'bar'], ['href', 'foo']],@html.at('a').to_a.sort
-      end
-      def test_attr
-        node = @html.at('div.baz')
-        assert_equal node['class'], node.attr('class')
-      end
-      def test_get_attribute
-        element = @html.at('div')
-        assert_equal 'baz', element.get_attribute('class')
-        assert_equal 'baz', element['class']
-        element['href'] = "javascript:alert(\"AGGA-KA-BOO!\")"
-        assert_match(/%22AGGA-KA-BOO!%22/, element.to_html)
-      end
-      # The HTML parser ignores namespaces, so even properly declared namespaces
-      # are treated as as undeclared and have to be accessed via prefix:tagname
-      def test_ns_attribute
-        html = '<i foo:bar="baz"></i>'
-        doc = Nokogiri::HTML(html)
-        assert_equal 'baz', (doc%'i')['foo:bar']
-      end
-      def test_css_path_round_trip
-        doc = Nokogiri::HTML(File.read(HTML_FILE))
-        %w{ #header small div[2] div.post body }.each do |css_sel|
-          ele = doc.at css_sel
-          assert_equal ele, doc.at(ele.css_path), ele.css_path
-        end
-      end
-      def test_path_round_trip
-        doc = Nokogiri::HTML(File.read(HTML_FILE))
-        %w{ #header small div[2] div.post body }.each do |css_sel|
-          ele = doc.at css_sel
-          assert_equal ele, doc.at(ele.path), ele.path
-        end
-      end
-      def test_append_with_document
-        assert_raises(ArgumentError) do
-          @html.root << Nokogiri::HTML::Document.new
-        end
-      end
-      ###
-      # Make sure a document that doesn't declare a meta encoding returns
-      # nil.
-      def test_meta_encoding
-        assert_nil @html.meta_encoding
-      end
-      def test_description
-        assert desc = @html.at('a.bar').description
-        assert_equal 'a', desc.name
-      end
-      def test_ancestors_with_selector
-        assert node = @html.at('a.bar').child
-        assert list = node.ancestors('.baz')
-        assert_equal 1, list.length
-        assert_equal 'div', list.first.name
-      end
-      def test_matches_inside_fragment
-        fragment = DocumentFragment.new @html
-        fragment << XML::Node.new('a', @html)
-        a = fragment.children.last
-        assert a.matches?('a'), 'a should match'
-      end
-      def test_css_matches?
-        assert node = @html.at('a.bar')
-        assert node.matches?('a.bar')
-      end
-      def test_xpath_matches?
-        assert node = @html.at('//a')
-        assert node.matches?('//a')
-      end
-      def test_unlink_then_swap
-        node = @html.at('a')
-        node.unlink
-        another_node = @html.at('div')
-        assert another_node, 'should have a node'
-        # This used to segv
-        assert node.add_previous_sibling another_node
-      end
-      def test_swap
-        @html.at('div').swap('<a href="foo">bar</a>')
-        a_tag = @html.css('a').first
-        assert_equal 'body', a_tag.parent.name
-        assert_equal 0, @html.css('div').length
-      end
-      def test_swap_with_regex_characters
-        @html.at('div').swap('<a href="foo">ba)r</a>')
-        a_tag = @html.css('a').first
-        assert_equal 'ba)r', a_tag.text
-      end
-      def test_attribute_decodes_entities
-        node = @html.at('div')
-        node['href'] = 'foo&bar'
-        assert_equal 'foo&bar', node['href']
-        node['href'] += '&baz'
-        assert_equal 'foo&bar&baz', node['href']
-      end
-      def test_parse_config_option
-        node = @html.at('div')
-        options = nil
-        node.parse("<div></div>") do |config|
-          options = config
-        end
-        assert_equal Nokogiri::XML::ParseOptions::DEFAULT_HTML, options.to_i
-      end
-      def test_fragment_handler_does_not_regurge_on_invalid_attributes
-        iframe = %Q{<iframe style="width: 0%; height: 0px" src="http://someurl" allowtransparency></iframe>}
-        assert @html.at('div').fragment(iframe)
-      end
-      def test_fragment
-        fragment = @html.fragment(<<-eohtml)
-          hello
-          <div class="foo">
-            <p>bar</p>
-          </div>
-          world
-        eohtml
-        assert_match(/^hello/, fragment.inner_html.strip)
-        assert_equal 3, fragment.children.length
-        assert p_tag = fragment.css('p').first
-        assert_equal 'div', p_tag.parent.name
-        assert_equal 'foo', p_tag.parent['class']
-      end
-      def test_fragment_serialization
-        fragment = Nokogiri::HTML.fragment("<div>foo</div>")
-        assert_equal "<div>foo</div>", fragment.serialize.chomp
-        assert_equal "<div>foo</div>", fragment.to_xml.chomp
-        assert_equal "<div>foo</div>", fragment.inner_html
-        assert_equal "<div>foo</div>", fragment.to_html
-        assert_equal "<div>foo</div>", fragment.to_s
-      end
-      def test_to_html_does_not_contain_entities
-        return unless defined?(NKF) # NKF is not implemented on Rubinius as of 2009-11-23
-        html = NKF.nkf("-e --msdos", <<-EOH)
-        <html><body>
-        <p> test paragraph
-        foo bar </p>
-        </body></html>
-        EOH
-        nokogiri = Nokogiri::HTML.parse(html)
-        if RUBY_PLATFORM =~ /java/
-          # NKF linebreak modes are not supported as of jruby 1.2
-          # see http://jira.codehaus.org/browse/JRUBY-3602 for status
-          assert_equal "<p>testparagraph\nfoobar</p>",
-            nokogiri.at("p").to_html.gsub(/ /, '')
-        else
-          assert_equal "<p>testparagraph\r\nfoobar</p>",
-            nokogiri.at("p").to_html.gsub(/ /, '')
-        end
-      end
-    end
-  end
-end

data/bundle/jruby/1.9/gems/nokogiri-1.6.1-java/test/html/test_node_encoding.rb DELETED Viewed

@@ -1,27 +0,0 @@
-# -*- coding: utf-8 -*-
-require "helper"
-module Nokogiri
-  module HTML
-    if RUBY_VERSION =~ /^1\.9/
-      class TestNodeEncoding < Nokogiri::TestCase
-        def test_inner_html
-          doc = Nokogiri::HTML File.open(SHIFT_JIS_HTML, 'rb')
-          hello = "こんにちは"
-          contents = doc.at('h2').inner_html
-          assert_equal doc.encoding, contents.encoding.name
-          assert_match hello.encode('Shift_JIS'), contents
-          contents = doc.at('h2').inner_html(:encoding => 'UTF-8')
-          assert_match hello, contents
-          doc.encoding = 'UTF-8'
-          contents = doc.at('h2').inner_html
-          assert_match hello, contents
-        end
-      end
-    end
-  end
-end

data/bundle/jruby/1.9/gems/nokogiri-1.6.1-java/test/namespaces/test_additional_namespaces_in_builder_doc.rb DELETED Viewed

@@ -1,14 +0,0 @@
-require "helper"
-module Nokogiri
-  module XML
-    class TestAdditionalNamespacesInBuilderDoc < Nokogiri::TestCase
-      def test_builder_namespaced_root_node_ns
-        b = Nokogiri::XML::Builder.new do |x|
-          x[:foo].RDF(:'xmlns:foo' => 'http://foo.io')
-        end
-        assert_equal 'http://foo.io', b.doc.root.namespace.href
-      end
-    end
-  end
-end

data/bundle/jruby/1.9/gems/nokogiri-1.6.1-java/test/namespaces/test_namespaces_in_builder_doc.rb DELETED Viewed

@@ -1,75 +0,0 @@
-require "helper"
-module Nokogiri
-  module XML
-    class TestNamespacesInBuilderDoc < Nokogiri::TestCase
-      def setup
-        super
-        b = Nokogiri::XML::Builder.new do |x|
-          x.fruit(:xmlns => 'ns:fruit', :'xmlns:veg' => 'ns:veg', :'xmlns:xlink' => 'http://www.w3.org/1999/xlink') do
-            x.pear { x.bosc }
-            x.orange
-            x[:veg].carrot do
-              x.cheese(:xmlns => 'ns:dairy', :'xlink:href' => 'http://example.com/cheese/')
-            end
-            x[:meat].bacon(:'xmlns:meat' => 'ns:meat') do
-              x.apple :count => 2
-              x[:veg].tomato
-            end
-          end
-        end
-        @doc = b.doc
-      end
-      def check_namespace e
-        e.namespace.nil? ? nil : e.namespace.href
-      end
-      def test_builder_default_ns
-        assert_equal 'ns:fruit', check_namespace(@doc.root)
-      end
-      def test_builder_parent_default_ns
-        assert_equal 'ns:fruit', check_namespace(@doc.root.elements[0])
-        assert_equal 'ns:fruit', check_namespace(@doc.root.elements[1])
-      end
-      def test_builder_grandparent_default_ns
-        assert_equal 'ns:fruit', check_namespace(@doc.root.elements[0].elements[0])
-      end
-      def test_builder_parent_nondefault_ns
-        assert_equal 'ns:veg',   check_namespace(@doc.root.elements[2])
-      end
-      def test_builder_single_decl_ns_1
-        assert_equal 'ns:dairy', check_namespace(@doc.root.elements[2].elements[0])
-      end
-      def test_builder_nondefault_attr_ns
-        assert_equal 'http://www.w3.org/1999/xlink',
-          check_namespace(@doc.root.elements[2].elements[0].attribute_nodes.find { |a| a.name =~ /href/ })
-      end
-      def test_builder_single_decl_ns_2
-        assert_equal 'ns:meat',  check_namespace(@doc.root.elements[3])
-      end
-      def test_builder_buried_default_ns
-        assert_equal 'ns:fruit',  check_namespace(@doc.root.elements[3].elements[0])
-      end
-      def test_builder_buried_decl_ns
-        assert_equal 'ns:veg',  check_namespace(@doc.root.elements[3].elements[1])
-      end
-      def test_builder_namespace_count
-        n = @doc.root.clone
-        n.children.each(&:remove)
-        ns_attrs = n.to_xml.scan(/\bxmlns(?::.+?)?=/)
-        assert_equal 3, ns_attrs.length
-      end
-      def test_builder_namespaced_attribute_on_unparented_node
-        doc = Nokogiri::XML::Builder.new do |x|
-          x.root('xmlns:foo' => 'http://foo.io') {
-            x.obj('foo:attr' => 'baz')
-          }
-        end.doc
-        assert_equal 'http://foo.io', doc.root.children.first.attribute_nodes.first.namespace.href
-      end
-    end
-  end
-end