libxml-ruby 3.2.2-x64-mingw-ucrt

data/test/test_error.rb

@@ -0,0 +1,178 @@
+# encoding: UTF-8
+
+require_relative './test_helper'
+require 'stringio'
+
+class TestError < Minitest::Test
+  # def test_error_codes
+  #   assert_equal(4, LibXML::XML::Error::DTD)
+  #   assert_equal(4, LibXML::XML::Error.const_get('DTD'))
+  #
+  #   assert_equal(4, LibXML::XML::Error::DOCUMENT_EMPTY)
+  #   assert_equal(4, LibXML::XML::Error.const_get('DOCUMENT_EMPTY'))
+  # end
+  #
+  # def test_invalid_handler
+  #   assert_raises(RuntimeError) do
+  #     LibXML::XML::Error.set_handler
+  #   end
+  # end
+  #
+  # def test_handler
+  #   exception = nil
+  #   LibXML::XML::Error.set_handler do |error|
+  #     exception = error
+  #   end
+  #
+  #   # Raise the error
+  #   error = assert_raises(LibXML::XML::Error) do
+  #     LibXML::XML::Reader.string('<foo').read
+  #   end
+  #   assert_equal(exception, error)
+  #
+  #   # Check the handler worked
+  #   refute_nil(exception)
+  #   assert_kind_of(LibXML::XML::Error, exception)
+  #   assert_equal("Fatal error: Couldn't find end of Start Tag foo at :1.", exception.message)
+  #   assert_equal(LibXML::XML::Error::PARSER, exception.domain)
+  #   assert_equal(LibXML::XML::Error::GT_REQUIRED, exception.code)
+  #   assert_equal(LibXML::XML::Error::FATAL, exception.level)
+  #   assert_nil(exception.file)
+  #   assert_equal(1, exception.line)
+  #   assert_equal('foo', exception.str1)
+  #   assert_nil(exception.str2)
+  #   assert_nil(exception.str3)
+  #   assert_equal(0, exception.int1)
+  #   assert_equal(5, exception.int2)
+  #   assert_nil(exception.node)
+  # end
+  #
+  # def test_reset_handler
+  #   exception = nil
+  #   LibXML::XML::Error.set_handler do |error|
+  #     exception = error
+  #   end
+  #
+  #   LibXML::XML::Error.reset_handler
+  #   LibXML::XML::Reader.string('<foo')
+  #   assert_nil(exception)
+  # end
+  #
+  # def test_get_handler
+  #   assert_respond_to(LibXML::XML::Error, :get_handler)
+  #   assert_equal(0, LibXML::XML::Error.method(:get_handler).arity)
+  #
+  #   saved_handler = LibXML::XML::Error.get_handler
+  #   LibXML::XML::Error.set_handler{ puts "New handler" }
+  #   refute_equal(LibXML::XML::Error.get_handler, saved_handler)
+  #
+  #   LibXML::XML::Error.set_handler(&saved_handler)
+  #   assert_equal(LibXML::XML::Error.get_handler, saved_handler)
+  # end
+  #
+  # def test_verbose_handler
+  #   LibXML::XML::Error.set_handler(&LibXML::XML::Error::VERBOSE_HANDLER)
+  #   output = StringIO.new
+  #   original_stderr = Object::STDERR
+  #
+  #   Object.const_set(:STDERR, output)
+  #   begin
+  #     assert_raises(LibXML::XML::Error) do
+  #       LibXML::XML::Parser.string('<foo><bar/></foz>').parse
+  #     end
+  #   ensure
+  #     Object.const_set(:STDERR, original_stderr)
+  #   end
+  #   assert_equal("Fatal error: Opening and ending tag mismatch: foo line 1 and foz at :1.\n", output.string)
+  # end
+  #
+  # def test_no_hanlder
+  #   LibXML::XML::Error.reset_handler
+  #   output = StringIO.new
+  #   original_stderr = Object::STDERR
+  #
+  #   Object.const_set(:STDERR, output)
+  #   begin
+  #     assert_raises(LibXML::XML::Error) do
+  #       LibXML::XML::Parser.string('<foo><bar/></foz>').parse
+  #     end
+  #   ensure
+  #     Object.const_set(:STDERR, original_stderr)
+  #   end
+  #   assert_equal('', output.string)
+  # end
+  #
+  # def test_parse_error
+  #   exception = assert_raises(LibXML::XML::Error) do
+  #     LibXML::XML::Parser.string('<foo><bar/></foz>').parse
+  #   end
+  #
+  #   assert_instance_of(LibXML::XML::Error, exception)
+  #   assert_equal("Fatal error: Opening and ending tag mismatch: foo line 1 and foz at :1.", exception.message)
+  #   assert_equal(LibXML::XML::Error::PARSER, exception.domain)
+  #   assert_equal(LibXML::XML::Error::TAG_NAME_MISMATCH, exception.code)
+  #   assert_equal(LibXML::XML::Error::FATAL, exception.level)
+  #   assert_nil(exception.file)
+  #   assert_equal(1, exception.line)
+  # end
+  #
+  # def test_xpath_error
+  #   doc = LibXML::XML::Document.file(File.join(File.dirname(__FILE__), 'model/soap.xml'))
+  #
+  #   exception = assert_raises(LibXML::XML::Error) do
+  #     doc.find('/foo[bar=test')
+  #   end
+  #
+  #   assert_instance_of(LibXML::XML::Error, exception)
+  #   assert_equal("Error: Invalid predicate.", exception.message)
+  #   assert_equal(LibXML::XML::Error::XPATH, exception.domain)
+  #   assert_equal(LibXML::XML::Error::XPATH_INVALID_PREDICATE_ERROR, exception.code)
+  #   assert_equal(LibXML::XML::Error::ERROR, exception.level)
+  #   assert_nil(exception.file)
+  #   assert_nil(nil)
+  # end
+
+  def test_double_parse
+    LibXML::XML::Parser.register_error_handler(lambda {|msg| nil })
+    parser = LibXML::XML::Parser.string("<test>something</test>")
+    parser.parse
+
+    error = assert_raises(LibXML::XML::Error) do
+      # Try parsing a second time
+      parser.parse
+    end
+
+    assert_equal(" LibXML::XML::Error.", error.to_s)
+  end
+
+  # def test_libxml_parser_empty_string
+  #   xp = LibXML::XML::Parser.new
+  #
+  #   error = assert_raises(TypeError) do
+  #     xp.string = nil
+  #   end
+  #   assert_equal('wrong argument type nil (expected String)', error.to_s)
+  #
+  #   error = assert_raises(ArgumentError) do
+  #     xp.string = ''
+  #   end
+  #   assert_equal('Must specify a string with one or more characters', error.to_s)
+  # end
+  #
+  # def test_error_domain_to_s
+  #   exception = assert_raises(LibXML::XML::Error) do
+  #     LibXML::XML::Parser.string('<foo href="http://example.org/cgi?k1=v1&k2=v2"></foo>').parse
+  #   end
+  #
+  #   assert_equal(LibXML::XML::Error::PARSER, exception.domain)
+  #   assert_equal("PARSER",exception.domain_to_s)
+  # end
+  #
+  # def test_error_code_to_s
+  #   exception = assert_raises(LibXML::XML::Error) do
+  #     LibXML::XML::Parser.string('<foo href="http://example.org/cgi?k1=v1&k2=v2"></foo>').parse
+  #   end
+  #   assert_equal(LibXML::XML::Error::ENTITYREF_SEMICOL_MISSING, exception.code)
+  #   assert_equal("ENTITYREF_SEMICOL_MISSING",exception.code_to_s)
+  # end
+end

data/test/test_helper.rb

@@ -0,0 +1,9 @@
+# encoding: UTF-8
+
+# To make testing/debugging easier, test within this source tree versus an installed gem
+
+require 'bundler/setup'
+require 'minitest/autorun'
+require 'libxml-ruby'
+
+STDOUT.write "\nlibxml2: #{LibXML::XML::LIBXML_VERSION}\n#{RUBY_DESCRIPTION}\n\n"

data/test/test_html_parser.rb

@@ -0,0 +1,162 @@
+# encoding: UTF-8
+
+require_relative './test_helper'
+require 'stringio'
+
+class HTMLParserTest < Minitest::Test
+  def html_file
+    File.expand_path(File.join(File.dirname(__FILE__), 'model/ruby-lang.html'))
+  end
+
+  # -----  Sources  ------
+  def test_file
+    xp = LibXML::XML::HTMLParser.file(html_file)
+    assert_instance_of(LibXML::XML::HTMLParser, xp)
+    doc = xp.parse
+    refute_nil(doc)
+  end
+
+  def test_noexistent_file
+    error = assert_raises(LibXML::XML::Error) do
+      LibXML::XML::HTMLParser.file('i_dont_exist.xml')
+    end
+
+    assert_equal('Warning: failed to load external entity "i_dont_exist.xml".', error.to_s)
+  end
+
+  def test_nil_file
+    error = assert_raises(TypeError) do
+      LibXML::XML::HTMLParser.file(nil)
+    end
+
+    assert_match(/nil into String/, error.to_s)
+  end
+
+  def test_io
+    File.open(html_file) do |io|
+      xp = LibXML::XML::HTMLParser.io(io)
+      assert_instance_of(LibXML::XML::HTMLParser, xp)
+
+      doc = xp.parse
+      assert_instance_of(LibXML::XML::Document, doc)
+    end
+  end
+
+  def test_io_gc
+    # Test that the reader keeps a reference
+    # to the io object
+    file = File.open(html_file)
+    parser = LibXML::XML::HTMLParser.io(file)
+    file = nil
+    GC.start
+    assert(parser.parse)
+  end
+
+  def test_nil_io
+    error = assert_raises(TypeError) do
+      LibXML::XML::HTMLParser.io(nil)
+    end
+
+    assert_equal("Must pass in an IO object", error.to_s)
+  end
+
+  def test_string_io
+    data = File.read(html_file)
+    io = StringIO.new(data)
+    xp = LibXML::XML::HTMLParser.io(io)
+    assert_instance_of(LibXML::XML::HTMLParser, xp)
+
+    doc = xp.parse
+    assert_instance_of(LibXML::XML::Document, doc)
+  end
+
+  def test_string
+    str = '<html><body><p>hi</p></body></html>'
+    xp = LibXML::XML::HTMLParser.string(str)
+
+    assert_instance_of(LibXML::XML::HTMLParser, xp)
+    assert_instance_of(LibXML::XML::HTMLParser, xp)
+
+    doc = xp.parse
+    assert_instance_of(LibXML::XML::Document, doc)
+  end
+
+  def test_nil_string
+    error = assert_raises(TypeError) do
+      LibXML::XML::HTMLParser.string(nil)
+    end
+
+    assert_equal("wrong argument type nil (expected String)", error.to_s)
+  end
+
+  def test_parse
+    html = <<-EOS
+      <html>
+        <head>
+          <meta name=keywords content=nasty>
+        </head>
+        <body>Hello<br>World</html>
+   EOS
+
+    parser = LibXML::XML::HTMLParser.string(html, :options => LibXML::XML::HTMLParser::Options::NOBLANKS)
+    doc = parser.parse
+    assert_instance_of LibXML::XML::Document, doc
+
+    root = doc.root
+    assert_instance_of LibXML::XML::Node, root
+    assert_equal 'html', root.name
+
+    head = root.child
+    assert_instance_of LibXML::XML::Node, head
+    assert_equal 'head', head.name
+
+    meta = head.child
+    assert_instance_of LibXML::XML::Node, meta
+    assert_equal 'meta', meta.name
+    assert_equal 'keywords', meta[:name]
+    assert_equal 'nasty', meta[:content]
+
+    body = head.next
+    assert_instance_of LibXML::XML::Node, body
+    assert_equal 'body', body.name
+
+    hello = body.child
+    # It appears that some versions of libxml2 add a layer of <p>
+    # cant figure our why or how, so this skips it if there
+    hello = hello.child if hello.name == "p"
+
+    assert_instance_of LibXML::XML::Node, hello
+    assert_equal 'Hello', hello.content
+
+    br = hello.next
+    assert_instance_of LibXML::XML::Node, br
+    assert_equal 'br', br.name
+
+    world = br.next
+    assert_instance_of LibXML::XML::Node, world
+    assert_equal 'World', world.content
+  end
+
+  def test_no_implied
+    html = "hello world"
+    parser = LibXML::XML::HTMLParser.string(html, :options => LibXML::XML::HTMLParser::Options::NOIMPLIED)
+    doc = parser.parse
+    assert_equal("<p>#{html}</p>", doc.root.to_s)
+  end
+
+  def test_comment
+    doc = LibXML::XML::HTMLParser.string('<!-- stuff -->', :options => LibXML::XML::HTMLParser::Options::NOIMPLIED |
+                                                                       LibXML::XML::HTMLParser::Options::NOERROR |
+                                                                       LibXML::XML::HTMLParser::Options::NOWARNING |
+                                                                       LibXML::XML::HTMLParser::Options::RECOVER |
+                                                                       LibXML::XML::HTMLParser::Options::NONET)
+    assert(doc)
+  end
+
+  def test_open_many_files
+    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/ruby-lang.html'))
+    1000.times do
+      LibXML::XML::HTMLParser.file(file).parse
+    end
+  end
+end

data/test/test_html_parser_context.rb

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+
+require_relative './test_helper'
+
+
+class TestHtmlParserContext < Minitest::Test
+  def test_default_options
+    context = LibXML::XML::HTMLParser::Context.new
+    assert_equal(0, context.options)
+  end
+
+  def test_no_options
+    context = LibXML::XML::HTMLParser::Context.new
+    context.options = 0
+    assert_equal(0, context.options)
+  end
+
+  def test_options
+    context = LibXML::XML::HTMLParser::Context.new
+    context.options = LibXML::XML::HTMLParser::Options::NOERROR
+    assert_equal(LibXML::XML::HTMLParser::Options::NOERROR, context.options)
+  end
+end

data/test/test_namespace.rb

@@ -0,0 +1,60 @@
+# encoding: UTF-8
+
+require_relative './test_helper'
+
+
+class TestNS < Minitest::Test
+  def setup
+    file = File.join(File.dirname(__FILE__), 'model/soap.xml')
+    @doc = LibXML::XML::Document.file(file)
+  end
+
+  def teardown
+    @doc = nil
+  end
+
+  def test_create_ns
+    node = LibXML::XML::Node.new('foo')
+    ns = LibXML::XML::Namespace.new(node, 'my_namepace', 'http://www.mynamespace.com')
+    assert_equal(ns.prefix, 'my_namepace')
+    assert_equal(ns.href, 'http://www.mynamespace.com')
+  end
+
+  def test_create_default_ns
+    node = LibXML::XML::Node.new('foo')
+    ns = LibXML::XML::Namespace.new(node, nil, 'http://www.mynamespace.com')
+    assert_nil(ns.prefix)
+    assert_equal(ns.href, 'http://www.mynamespace.com')
+  end
+
+  def test_create_unbound_ns
+    error = assert_raises(TypeError) do
+      LibXML::XML::Namespace.new(nil, 'my_namepace', 'http://www.mynamespace.com')
+    end
+    assert_equal('wrong argument type nil (expected Data)', error.to_s)
+  end
+
+  def test_duplicate_ns
+    node = LibXML::XML::Node.new('foo')
+    LibXML::XML::Namespace.new(node, 'myname', 'http://www.mynamespace.com')
+    assert_raises(LibXML::XML::Error) do
+      LibXML::XML::Namespace.new(node, 'myname', 'http://www.mynamespace.com')
+    end
+  end
+
+  def test_eql
+    node = LibXML::XML::Node.new('Envelope')
+
+    assert(node.namespaces.namespace.eql?(node.namespaces.namespace))
+  end
+
+  def test_equal
+    node1 = LibXML::XML::Node.new('Envelope')
+    ns1 = LibXML::XML::Namespace.new(node1, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
+
+    node2 = LibXML::XML::Node.new('Envelope')
+    ns2 = LibXML::XML::Namespace.new(node2, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
+
+    assert(ns1 == ns2)
+  end
+end

data/test/test_namespaces.rb

@@ -0,0 +1,200 @@
+# encoding: UTF-8
+
+require_relative './test_helper'
+
+
+class TestNamespaces < Minitest::Test
+  def setup
+    file = File.join(File.dirname(__FILE__), 'model/soap.xml')
+    @doc = LibXML::XML::Document.file(file)
+  end
+
+  def teardown
+    @doc = nil
+  end
+
+  def test_namespace_node
+    node = @doc.root
+    ns = node.namespaces.namespace
+    assert_equal('soap', ns.prefix)
+    assert_equal('http://schemas.xmlsoap.org/soap/envelope/', ns.href)
+  end
+
+  def test_namespace_attr
+    node = @doc.root
+    attr = node.attributes.get_attribute('encodingStyle')
+    assert_equal('soap', attr.ns.prefix)
+    assert_equal('soap', attr.namespaces.namespace.prefix)
+  end
+
+  def test_set_namespace_node
+    node = LibXML::XML::Node.new('Envelope')
+    assert_equal('<Envelope/>', node.to_s)
+
+    ns = LibXML::XML::Namespace.new(node, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
+    assert_equal("<Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\"/>", node.to_s)
+    assert_nil(node.namespaces.namespace)
+
+    # Now put the node in the soap namespace
+    node.namespaces.namespace = ns
+    refute_nil(node.namespaces.namespace)
+    assert_equal("<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\"/>", node.to_s)
+  end
+
+  def test_set_namespace_attribute
+    # Create node
+    node = LibXML::XML::Node.new('Envelope')
+    assert_equal('<Envelope/>', node.to_s)
+
+    # Create attribute
+    attr = LibXML::XML::Attr.new(node, "encodingStyle", "http://www.w3.org/2001/12/soap-encoding")
+    assert_equal('<Envelope encodingStyle="http://www.w3.org/2001/12/soap-encoding"/>',
+                 node.to_s)
+
+    # Create namespace attribute
+    ns = LibXML::XML::Namespace.new(node, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
+    assert_equal('<Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" encodingStyle="http://www.w3.org/2001/12/soap-encoding"/>',
+                  node.to_s)
+    assert_nil(node.namespaces.namespace)
+
+    # Now put the node in the soap namespace
+    node.namespaces.namespace = ns
+    refute_nil(node.namespaces.namespace)
+    assert_equal('<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" encodingStyle="http://www.w3.org/2001/12/soap-encoding"/>',
+                  node.to_s)
+
+    # Now put the attribute in the soap namespace
+    attr.namespaces.namespace = ns
+    refute_nil(node.namespaces.namespace)
+    assert_equal('<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" soap:encodingStyle="http://www.w3.org/2001/12/soap-encoding"/>',
+                  node.to_s)
+  end
+
+  def test_define_namespace
+    node = LibXML::XML::Node.new('Envelope')
+    assert_equal('<Envelope/>', node.to_s)
+
+    LibXML::XML::Namespace.new(node, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
+    assert_equal("<Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\"/>", node.to_s)
+    assert_nil(node.namespaces.namespace)
+  end
+
+  def test_define_default_namespace
+    node = LibXML::XML::Node.new('Envelope')
+    assert_equal('<Envelope/>', node.to_s)
+
+    LibXML::XML::Namespace.new(node, nil, 'http://schemas.xmlsoap.org/soap/envelope/')
+    assert_equal("<Envelope xmlns=\"http://schemas.xmlsoap.org/soap/envelope/\"/>", node.to_s)
+    # This seems wrong, but appears to be the way libxml works
+    assert_nil(node.namespaces.namespace)
+  end
+
+  def test_namespaces
+    node = @doc.find_first('//ns1:IdAndName',
+                           :ns1 => 'http://domain.somewhere.com')
+
+    namespaces = node.namespaces.sort
+    assert_equal(5, namespaces.length)
+
+    namespace = namespaces[0]
+    assert_instance_of(LibXML::XML::Namespace, namespace)
+    assert_nil(namespace.prefix)
+    assert_equal('http://services.somewhere.com', namespace.href)
+
+    namespace = namespaces[1]
+    assert_instance_of(LibXML::XML::Namespace, namespace)
+    assert_equal('ns1', namespace.prefix)
+    assert_equal('http://domain.somewhere.com', namespace.href)
+
+    namespace = namespaces[2]
+    assert_instance_of(LibXML::XML::Namespace, namespace)
+    assert_equal('soap', namespace.prefix)
+    assert_equal('http://schemas.xmlsoap.org/soap/envelope/', namespace.href)
+
+    namespace = namespaces[3]
+    assert_instance_of(LibXML::XML::Namespace, namespace)
+    assert_equal('xsd', namespace.prefix)
+    assert_equal('http://www.w3.org/2001/XMLSchema', namespace.href)
+
+    namespace = namespaces[4]
+    assert_instance_of(LibXML::XML::Namespace, namespace)
+    assert_equal('xsi', namespace.prefix)
+    assert_equal('http://www.w3.org/2001/XMLSchema-instance', namespace.href)
+  end
+
+  def test_namespace_definitions
+    ns_defs = @doc.root.namespaces.definitions
+    assert_equal(3, ns_defs.size)
+
+    namespace = ns_defs[0]
+    assert_instance_of(LibXML::XML::Namespace, namespace)
+    assert_equal('soap', namespace.prefix)
+    assert_equal('http://schemas.xmlsoap.org/soap/envelope/', namespace.href)
+
+    namespace = ns_defs[1]
+    assert_instance_of(LibXML::XML::Namespace, namespace)
+    assert_equal('xsd', namespace.prefix)
+    assert_equal('http://www.w3.org/2001/XMLSchema', namespace.href)
+
+    namespace = ns_defs[2]
+    assert_instance_of(LibXML::XML::Namespace, namespace)
+    assert_equal('xsi', namespace.prefix)
+    assert_equal('http://www.w3.org/2001/XMLSchema-instance', namespace.href)
+
+    node = @doc.root.find_first('//ns:getManufacturerNamesResponse',
+                                :ns => 'http://services.somewhere.com')
+    ns_defs = node.namespaces.definitions
+    assert_equal(1, ns_defs.size)
+
+    namespace = ns_defs[0]
+    assert_instance_of(LibXML::XML::Namespace, namespace)
+    assert_nil(namespace.prefix)
+    assert_equal('http://services.somewhere.com', namespace.href)
+  end
+
+  def test_find_by_prefix
+    namespace = @doc.root.namespaces.find_by_prefix('soap')
+
+    assert_instance_of(LibXML::XML::Namespace, namespace)
+    assert_equal('soap', namespace.prefix)
+    assert_equal('http://schemas.xmlsoap.org/soap/envelope/', namespace.href)
+  end
+
+  def test_find_default_ns
+    namespace = @doc.root.namespaces.find_by_prefix(nil)
+    assert_nil(namespace)
+
+    node = @doc.find_first('//ns1:getManufacturerNamesResponse',
+                           :ns1 => 'http://services.somewhere.com')
+    namespace = node.namespaces.find_by_prefix(nil)
+
+    assert_instance_of(LibXML::XML::Namespace, namespace)
+    assert_nil(namespace.prefix)
+    assert_equal('http://services.somewhere.com', namespace.href)
+  end
+
+  def test_find_ns_by_href
+    node = @doc.find_first('//ns1:getManufacturerNamesResponse',
+                           :ns1 => 'http://services.somewhere.com')
+
+    namespace = node.namespaces.find_by_href('http://schemas.xmlsoap.org/soap/envelope/')
+
+    assert_instance_of(LibXML::XML::Namespace, namespace)
+    assert_equal('soap', namespace.prefix)
+    assert_equal('http://schemas.xmlsoap.org/soap/envelope/', namespace.href)
+  end
+
+  def test_default_namespace
+    doc = LibXML::XML::Document.string('<Envelope xmlns="http://schemas.xmlsoap.org/soap/envelope/"/>')
+    ns = doc.root.namespaces.default
+    assert_equal(ns.href, 'http://schemas.xmlsoap.org/soap/envelope/')
+  end
+
+  def test_default_prefix
+    doc = LibXML::XML::Document.string('<Envelope xmlns="http://schemas.xmlsoap.org/soap/envelope/"/>')
+    doc.root.namespaces.default_prefix = 'soap'
+
+    node = doc.root.find_first('/soap:Envelope')
+    refute_nil(node)
+  end
+end