libxml-ruby 3.0.0 → 3.2.2

data/test/{tc_attr.rb → test_attr.rb}

@@ -1,10 +1,10 @@
 # encoding: UTF-8
 
-require './test_helper'
+require_relative './test_helper'
 
 class AttrNodeTest < Minitest::Test
   def setup
-    xp = XML::Parser.string(<<-EOS)
+    xp = LibXML::XML::Parser.string(<<-EOS)
     <CityModel
       xmlns="http://www.opengis.net/examples"
       xmlns:city="http://www.opengis.net/examples"
@@ -34,19 +34,19 @@ class AttrNodeTest < Minitest::Test
 
   def test_doc
     refute_nil(@doc)
-    assert_equal(XML::Encoding::NONE, @doc.encoding)
+    assert_equal(LibXML::XML::Encoding::NONE, @doc.encoding)
   end
 
   def test_types
     attribute = city_member.attributes.get_attribute('name')
-    assert_instance_of(XML::Attr, attribute)
+    assert_instance_of(LibXML::XML::Attr, attribute)
     assert_equal('attribute', attribute.node_type_name)
   end
 
   def test_name
     attribute = city_member.attributes.get_attribute('name')
     assert_equal('name', attribute.name)
-    assert_equal(Encoding::UTF_8, attribute.name.encoding) if defined?(Encoding)
+    assert_equal(Encoding::UTF_8, attribute.name.encoding)
 
     attribute = city_member.attributes.get_attribute('href')
     assert_equal('href', attribute.name)
@@ -62,7 +62,7 @@ class AttrNodeTest < Minitest::Test
   def test_value
     attribute = city_member.attributes.get_attribute('name')
     assert_equal('Cambridge', attribute.value)
-    assert_equal(Encoding::UTF_8, attribute.value.encoding) if defined?(Encoding)
+    assert_equal(Encoding::UTF_8, attribute.value.encoding)
 
     attribute = city_member.attributes.get_attribute('href')
     assert_equal('http://www.foo.net/cgi-bin/wfs?FeatureID=C10239', attribute.value)
@@ -72,12 +72,12 @@ class AttrNodeTest < Minitest::Test
     attribute = city_member.attributes.get_attribute('name')
     attribute.value = 'London'
     assert_equal('London', attribute.value)
-    assert_equal(Encoding::UTF_8, attribute.value.encoding) if defined?(Encoding)
+    assert_equal(Encoding::UTF_8, attribute.value.encoding)
 
     attribute = city_member.attributes.get_attribute('href')
     attribute.value = 'http://i.have.changed'
     assert_equal('http://i.have.changed', attribute.value)
-    assert_equal(Encoding::UTF_8, attribute.value.encoding) if defined?(Encoding)
+    assert_equal(Encoding::UTF_8, attribute.value.encoding)
   end
 
   def test_set_nil
@@ -91,8 +91,8 @@ class AttrNodeTest < Minitest::Test
     attributes = city_member.attributes
     assert_equal(5, attributes.length)
 
-    attr = XML::Attr.new(city_member, 'size', '50,000')
-    assert_instance_of(XML::Attr, attr)
+    attr = LibXML::XML::Attr.new(city_member, 'size', '50,000')
+    assert_instance_of(LibXML::XML::Attr, attr)
 
     attributes = city_member.attributes
     assert_equal(6, attributes.length)
@@ -115,9 +115,9 @@ class AttrNodeTest < Minitest::Test
   def test_create_ns
     assert_equal(5, city_member.attributes.length)
 
-    ns = XML::Namespace.new(city_member, 'my_namepace', 'http://www.mynamespace.com')
-    attr = XML::Attr.new(city_member, 'rating', 'rocks', ns)
-    assert_instance_of(XML::Attr, attr)
+    ns = LibXML::XML::Namespace.new(city_member, 'my_namepace', 'http://www.mynamespace.com')
+    attr = LibXML::XML::Attr.new(city_member, 'rating', 'rocks', ns)
+    assert_instance_of(LibXML::XML::Attr, attr)
     assert_equal('rating', attr.name)
     assert_equal('rocks', attr.value)
 
@@ -144,27 +144,27 @@ class AttrNodeTest < Minitest::Test
 
   def test_first
     attribute = city_member.attributes.first
-    assert_instance_of(XML::Attr, attribute)
+    assert_instance_of(LibXML::XML::Attr, attribute)
     assert_equal('name', attribute.name)
     assert_equal('Cambridge', attribute.value)
 
     attribute = attribute.next
-    assert_instance_of(XML::Attr, attribute)
+    assert_instance_of(LibXML::XML::Attr, attribute)
     assert_equal('type', attribute.name)
     assert_equal('simple', attribute.value)
 
     attribute = attribute.next
-    assert_instance_of(XML::Attr, attribute)
+    assert_instance_of(LibXML::XML::Attr, attribute)
     assert_equal('title', attribute.name)
     assert_equal('Trinity Lane', attribute.value)
 
     attribute = attribute.next
-    assert_instance_of(XML::Attr, attribute)
+    assert_instance_of(LibXML::XML::Attr, attribute)
     assert_equal('href', attribute.name)
     assert_equal('http://www.foo.net/cgi-bin/wfs?FeatureID=C10239', attribute.value)
 
     attribute = attribute.next
-    assert_instance_of(XML::Attr, attribute)
+    assert_instance_of(LibXML::XML::Attr, attribute)
     assert_equal('remoteSchema', attribute.name)
     assert_equal("city.xsd#xpointer(//complexType[@name='RoadType'])", attribute.value)
 

data/test/{tc_attr_decl.rb → test_attr_decl.rb}

@@ -1,10 +1,10 @@
 # encoding: UTF-8
 
-require './test_helper'
+require_relative './test_helper'
 
 class AttrDeclTest < Minitest::Test
   def setup
-    xp = XML::Parser.string(<<-EOS)
+    xp = LibXML::XML::Parser.string(<<-EOS)
 	<!DOCTYPE test [
 	  <!ELEMENT root (property*)>
 	  <!ELEMENT property EMPTY>
@@ -42,7 +42,7 @@ class AttrDeclTest < Minitest::Test
     # Get the attr_decl
     attr = elem.attributes.get_attribute('access')
     refute_nil(attr)
-    assert_equal(XML::Node::ATTRIBUTE_NODE, attr.node_type)
+    assert_equal(LibXML::XML::Node::ATTRIBUTE_NODE, attr.node_type)
     assert_equal('attribute', attr.node_type_name)
 
     # Get its value
@@ -56,7 +56,7 @@ class AttrDeclTest < Minitest::Test
     # Get the attr_decl
     attr_decl = elem.attributes.get_attribute('access')
     refute_nil(attr_decl)
-    assert_equal(XML::Node::ATTRIBUTE_DECL, attr_decl.node_type)
+    assert_equal(LibXML::XML::Node::ATTRIBUTE_DECL, attr_decl.node_type)
     assert_equal('attribute declaration', attr_decl.node_type_name)
 
     # Get its value
@@ -69,7 +69,7 @@ class AttrDeclTest < Minitest::Test
     attr_decl = elem.attributes.get_attribute('access')
 
     refute_nil(attr_decl)
-    assert_equal(XML::Node::ATTRIBUTE_DECL, attr_decl.node_type)
+    assert_equal(LibXML::XML::Node::ATTRIBUTE_DECL, attr_decl.node_type)
     assert_equal('attribute declaration', attr_decl.node_type_name)
   end
   
@@ -99,12 +99,12 @@ class AttrDeclTest < Minitest::Test
     attr_decl = elem.attributes.get_attribute('access')
 
     first_decl = attr_decl.prev
-    assert_equal(XML::Node::ATTRIBUTE_DECL, first_decl.node_type)
+    assert_equal(LibXML::XML::Node::ATTRIBUTE_DECL, first_decl.node_type)
     assert_equal('name', first_decl.name)
     assert_nil(first_decl.value)
 
     elem_decl = first_decl.prev
-    assert_equal(XML::Node::ELEMENT_DECL, elem_decl.node_type)
+    assert_equal(LibXML::XML::Node::ELEMENT_DECL, elem_decl.node_type)
   end
 
   def test_next
@@ -127,6 +127,6 @@ class AttrDeclTest < Minitest::Test
     attr_decl = elem.attributes.get_attribute('access')
 
     parent = attr_decl.parent
-    assert_instance_of(XML::Dtd, parent)
+    assert_instance_of(LibXML::XML::Dtd, parent)
   end
 end

data/test/{tc_attributes.rb → test_attributes.rb}

@@ -1,10 +1,10 @@
 # encoding: UTF-8
 
-require './test_helper'
+require_relative './test_helper'
 
 class AttributesTest < Minitest::Test
   def setup
-    xp = XML::Parser.string(<<-EOS)
+    xp = LibXML::XML::Parser.string(<<-EOS)
     <CityModel name="value"
       xmlns="http://www.opengis.net/examples"
       xmlns:city="http://www.opengis.net/examples"
@@ -33,14 +33,14 @@ class AttributesTest < Minitest::Test
 
   def test_attributes
     attributes = city_member.attributes
-    assert_instance_of(XML::Attributes, attributes)
+    assert_instance_of(LibXML::XML::Attributes, attributes)
     assert_equal(5, attributes.length)
   end
 
   def test_each
     attributes = city_member.attributes
     length = attributes.inject(0) do |result, attr|
-      assert_instance_of(XML::Attr, attr)
+      assert_instance_of(LibXML::XML::Attr, attr)
       result + 1
     end
     assert_equal(5, length)
@@ -50,25 +50,25 @@ class AttributesTest < Minitest::Test
     attributes = city_member.attributes
 
     attr = attributes.get_attribute('name')
-    assert_instance_of(XML::Attr, attr)
+    assert_instance_of(LibXML::XML::Attr, attr)
 
     attr = attributes.get_attribute('does_not_exist')
     assert_nil(attr)
 
     attr = attributes.get_attribute('name')
-    assert_instance_of(XML::Attr, attr)
+    assert_instance_of(LibXML::XML::Attr, attr)
 
     attr = attributes.get_attribute('href')
-    assert_instance_of(XML::Attr, attr)
-    assert_instance_of(XML::Namespace, attr.ns)
+    assert_instance_of(LibXML::XML::Attr, attr)
+    assert_instance_of(LibXML::XML::Namespace, attr.ns)
     assert_equal('xlink', attr.ns.prefix)
     assert_equal('http://www.w3.org/1999/xlink', attr.ns.href)
 
     attr = attributes.get_attribute_ns('http://www.w3.org/1999/xlink', 'href')
-    assert_instance_of(XML::Attr, attr)
+    assert_instance_of(LibXML::XML::Attr, attr)
 
     attr = attributes.get_attribute_ns('http://www.opengis.net/gml', 'remoteSchema')
-    assert_instance_of(XML::Attr, attr)
+    assert_instance_of(LibXML::XML::Attr, attr)
 
     attr = attributes.get_attribute_ns('http://i.dont.exist', 'nor do i')
     assert_nil(attr)

data/test/{tc_canonicalize.rb → test_canonicalize.rb}

@@ -1,24 +1,28 @@
 # encoding: UTF-8
-require './test_helper'
+require_relative './test_helper'
 
 class TestCanonicalize < Minitest::Test
+  def path(file)
+    File.join(File.dirname(__FILE__), file)
+  end
+  
   # (www.w3.org) 3.1 PIs, Comments, and Outside of Document Element
   # http://www.w3.org/TR/xml-c14n#Example-OutsideDoc
   def test_canonicalize_with_w3c_c14n_3_1
-    given_doc = XML::Document.file('c14n/given/example-1.xml')
+    given_doc = LibXML::XML::Document.file(self.path('c14n/given/example-1.xml'))
 
     # With Comments
-    expected_with_comments = IO.read('c14n/result/with-comments/example-1')
+    expected_with_comments = IO.read(self.path('c14n/result/with-comments/example-1'))
     assert_equal(expected_with_comments, given_doc.canonicalize(:comments => true))
 
     # Without Comments
-    expected_without_comments = IO.read('c14n/result/without-comments/example-1')
+    expected_without_comments = IO.read(self.path('c14n/result/without-comments/example-1'))
     assert_equal(expected_without_comments, given_doc.canonicalize)
     assert_equal(expected_without_comments, given_doc.canonicalize(:comments => false))
 
     # Without Comments (XML_C14N_1_1)
-    expected_1_1_without_comments = IO.read('c14n/result/1-1-without-comments/example-1')
-    mode = XML::Document::XML_C14N_1_1
+    expected_1_1_without_comments = IO.read(self.path('c14n/result/1-1-without-comments/example-1'))
+    mode = LibXML::XML::Document::XML_C14N_1_1
     assert_equal(expected_1_1_without_comments, given_doc.canonicalize(:mode => mode))
   end#test_canonicalize_with_w3c_c14n_3_1
 
@@ -26,12 +30,12 @@ class TestCanonicalize < Minitest::Test
   # (www.w3.org) 3.2 Whitespace in Document Content
   # http://www.w3.org/TR/xml-c14n#Example-WhitespaceInContent
   def test_canonicalize_with_w3c_c14n_3_2
-    given_doc = XML::Document.file('c14n/given/example-2.xml')
-    expected = IO.read('c14n/result/without-comments/example-2')
+    given_doc = LibXML::XML::Document.file(self.path('c14n/given/example-2.xml'))
+    expected = IO.read(self.path('c14n/result/without-comments/example-2'))
     assert_equal(expected, given_doc.canonicalize)
 
-    expected_1_1_without_comments = IO.read('c14n/result/1-1-without-comments/example-2')
-    mode = XML::Document::XML_C14N_1_1
+    expected_1_1_without_comments = IO.read(self.path('c14n/result/1-1-without-comments/example-2'))
+    mode = LibXML::XML::Document::XML_C14N_1_1
     assert_equal(expected_1_1_without_comments, given_doc.canonicalize(:mode => mode))
   end
 
@@ -41,24 +45,24 @@ class TestCanonicalize < Minitest::Test
   #   - Embedded DTD not parsed out of XML, therefore default attributes are
   #     not applied to canonicalization.
   def test_canonicalize_with_w3c_c14n_3_3
-    given_doc = XML::Document.file('c14n/given/example-3.xml')
-    expected = IO.read('c14n/result/without-comments/example-3')
+    given_doc = LibXML::XML::Document.file(self.path('c14n/given/example-3.xml'))
+    expected = IO.read(self.path('c14n/result/without-comments/example-3'))
     assert_equal(expected, given_doc.canonicalize)
 
-    expected_1_1_without_comments = IO.read('c14n/result/1-1-without-comments/example-3')
-    mode = XML::Document::XML_C14N_1_1
+    expected_1_1_without_comments = IO.read(self.path('c14n/result/1-1-without-comments/example-3'))
+    mode = LibXML::XML::Document::XML_C14N_1_1
     assert_equal(expected_1_1_without_comments, given_doc.canonicalize(:mode => mode))
   end
 
   # (www.w3.org) 3.4 Character Modifications and Character References
   # http://www.w3.org/TR/xml-c14n#Example-Chars
   def test_canonicalize_with_w3c_c14n_3_4
-    given_doc = XML::Document.file('c14n/given/example-4.xml')
-    expected = IO.read('c14n/result/without-comments/example-4')
+    given_doc = LibXML::XML::Document.file(self.path('c14n/given/example-4.xml'))
+    expected = IO.read(self.path('c14n/result/without-comments/example-4'))
     assert_equal(expected, given_doc.canonicalize)
 
-    expected_1_1_without_comments = IO.read('c14n/result/1-1-without-comments/example-4')
-    mode = XML::Document::XML_C14N_1_1
+    expected_1_1_without_comments = IO.read(self.path('c14n/result/1-1-without-comments/example-4'))
+    mode = LibXML::XML::Document::XML_C14N_1_1
     assert_equal(expected_1_1_without_comments, given_doc.canonicalize(:mode => mode))
   end
 
@@ -67,20 +71,20 @@ class TestCanonicalize < Minitest::Test
   # (2012-02-20) Failing likely due to a logic error
   #   - libxml2(c14n.c:1788) XML_ENTITY_REF_NODE is invalid node for parsing.
   def test_canonicalize_with_w3c_c14n_3_5
-    given_doc = XML::Document.file('c14n/given/example-5.xml')
+    #given_doc = LibXML::XML::Document.file(self.path('c14n/given/example-5.xml'))
 
     # With Comments
-    expected_with_comments = IO.read('c14n/result/with-comments/example-5')
+    #expected_with_comments = IO.read(self.path('c14n/result/with-comments/example-5'))
 
     # TODO - CANNOT COMPLETE TEST unless libxml2 supports additional node types.
     #assert_equal(expected_with_comments, given_doc.canonicalize(:comments => true))
 
     # Without Comments
-    expected_without_comments = IO.read('c14n/result/without-comments/example-5')
+    #expected_without_comments = IO.read(self.path('c14n/result/without-comments/example-5'))
     # TODO - CANNOT COMPLETE TEST unless libxml2 supports additional node types.
     #assert_equal(expected_without_comments, given_doc.canonicalize(:comments => false))
-    expected_1_1_without_comments = IO.read('c14n/result/1-1-without-comments/example-5')
-    mode = XML::Document::XML_C14N_1_1
+    #expected_1_1_without_comments = IO.read(self.path('c14n/result/1-1-without-comments/example-5'))
+    #mode = LibXML::XML::Document::XML_C14N_1_1
 
     # TODO - CANNOT COMPLETE TEST unless libxml2 supports additional node types.
     #assert_equal(expected_1_1_without_comments, given_doc.canonicalize(:mode => mode))
@@ -89,20 +93,12 @@ class TestCanonicalize < Minitest::Test
   # (www.w3.org) 3.6 UTF-8 Encoding
   # http://www.w3.org/TR/xml-c14n#Example-UTF8
   def test_canonicalize_with_w3c_c14n_3_6
-    given_doc = XML::Document.file('c14n/given/example-6.xml')
-    if defined?(Encoding)
-      expected = IO.read('c14n/result/without-comments/example-6', :encoding => Encoding::UTF_8)
-    else
-      expected = IO.read('c14n/result/without-comments/example-6')
-    end
+    given_doc = LibXML::XML::Document.file(self.path('c14n/given/example-6.xml'))
+    expected = IO.read(self.path('c14n/result/without-comments/example-6'), :encoding => Encoding::UTF_8)
     assert_equal(expected, given_doc.canonicalize)
 
-    if defined?(Encoding)
-      expected_1_1_without_comments = IO.read('c14n/result/1-1-without-comments/example-6', :encoding => Encoding::UTF_8)
-    else
-      expected_1_1_without_comments = IO.read('c14n/result/1-1-without-comments/example-6')
-    end
-    mode = XML::Document::XML_C14N_1_1
+    expected_1_1_without_comments = IO.read(self.path('c14n/result/1-1-without-comments/example-6'), :encoding => Encoding::UTF_8)
+    mode = LibXML::XML::Document::XML_C14N_1_1
     assert_equal(expected_1_1_without_comments, given_doc.canonicalize(:mode => mode))
   end
 
@@ -110,13 +106,13 @@ class TestCanonicalize < Minitest::Test
   # http://www.w3.org/TR/xml-c14n#Example-DocSubsets
   def test_canonicalize_with_w3c_c14n_3_7
     # Non Canonicalized Document
-    given_doc = XML::Document.file('c14n/given/example-7.xml')
-    expected = IO.read('c14n/result/without-comments/example-7')
+    # given_doc = LibXML::XML::Document.file(self.path('c14n/given/example-7.xml'))
+    #expected = IO.read(self.path('c14n/result/without-comments/example-7'))
 
-    e1_node = given_doc.find_first('ietf:e1', 'ietf:http://www.ietf.org')
+    # e1_node = given_doc.find_first('ietf:e1', 'ietf:http://www.ietf.org')
 
     # Select current node, all child nodes, all attributes and namespace nodes
-    subdoc_nodes = e1_node.find("(.//.|.//@id|namespace::*)")
+    #subdoc_nodes = e1_node.find("(.//.|.//@id|namespace::*)")
 
     # TODO - This fails because the namespace nodes aren't taken into account
     # assert_equal(expected, given_doc.canonicalize(:nodes => subdoc_nodes))

data/test/test_deprecated_require.rb

@@ -0,0 +1,12 @@
+# encoding: UTF-8
+
+require 'xml/libxml'
+
+class TestDeprecatedRequire < Minitest::Test
+  def test_basic
+    xp = LibXML::XML::Parser.string('<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>')
+    assert_instance_of(LibXML::XML::Parser, xp)
+    @doc = xp.parse
+    assert_instance_of(LibXML::XML::Document, @doc)
+  end
+end

data/test/{tc_document.rb → test_document.rb}

@@ -1,12 +1,12 @@
 # encoding: UTF-8
-require './test_helper'
+require_relative './test_helper'
 
 class TestDocument < Minitest::Test
   def setup
-    xp = XML::Parser.string('<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>')
-    assert_instance_of(XML::Parser, xp)
+    xp = LibXML::XML::Parser.string('<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>')
+    assert_instance_of(LibXML::XML::Parser, xp)
     @doc = xp.parse
-    assert_instance_of(XML::Document, @doc)
+    assert_instance_of(LibXML::XML::Document, @doc)
   end
 
   def teardown
@@ -14,24 +14,24 @@ class TestDocument < Minitest::Test
   end
 
   def test_klass
-    assert_instance_of(XML::Document, @doc)
+    assert_instance_of(LibXML::XML::Document, @doc)
   end
 
   def test_context
     context = @doc.context
-    assert_instance_of(XML::XPath::Context, context)
+    assert_instance_of(LibXML::XML::XPath::Context, context)
   end
 
   def test_find
     set = @doc.find('/ruby_array/fixnum')
-    assert_instance_of(XML::XPath::Object, set)
+    assert_instance_of(LibXML::XML::XPath::Object, set)
     assert_raises(NoMethodError) {
-      xpt = set.xpath
+      set.xpath
     }
   end
 
   def test_compression
-    if XML.enabled_zlib?
+    if LibXML::XML.enabled_zlib?
       0.upto(9) do |i|
         assert_equal(i, @doc.compression = i)
         assert_equal(i, @doc.compression)
@@ -59,41 +59,41 @@ class TestDocument < Minitest::Test
   def test_version
     assert_equal('1.0', @doc.version)
 
-    doc = XML::Document.new('6.9')
+    doc = LibXML::XML::Document.new('6.9')
     assert_equal('6.9', doc.version)
   end
 
   def test_write_root
-    @doc.root = XML::Node.new('rubynet')
-    assert_instance_of(XML::Node, @doc.root)
-    assert_instance_of(XML::Document, @doc.root.doc)
+    @doc.root = LibXML::XML::Node.new('rubynet')
+    assert_instance_of(LibXML::XML::Node, @doc.root)
+    assert_instance_of(LibXML::XML::Document, @doc.root.doc)
     assert_equal("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<rubynet/>\n",
                  @doc.to_s(:indent => false))
   end
 
   def test_doc_node_type
-    assert_equal(XML::Node::DOCUMENT_NODE, XML::Document.new.node_type)
+    assert_equal(LibXML::XML::Node::DOCUMENT_NODE, LibXML::XML::Document.new.node_type)
   end
 
   def test_doc_node_type_name
-    assert_equal('document_xml', XML::Document.new.node_type_name)
+    assert_equal('document_xml', LibXML::XML::Document.new.node_type_name)
   end
 
   def test_xhtml
-		doc = XML::Document.new
+		doc = LibXML::XML::Document.new
 		assert(!doc.xhtml?)
-    XML::Dtd.new "-//W3C//DTD XHTML 1.0 Transitional//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", nil, doc, true
+    LibXML::XML::Dtd.new "-//W3C//DTD XHTML 1.0 Transitional//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", nil, doc, true
 		assert(doc.xhtml?)
-	end
+  end
 
   def test_document_root
     doc1 = LibXML::XML::Document.string("<one/>")
     doc2 = LibXML::XML::Document.string("<two/>")
 
-    error = assert_raises(XML::Error) do
+    error = assert_raises(LibXML::XML::Error) do
       doc1.root = doc2.root
     end
-    assert_equal(" Nodes belong to different documents.  You must first import the node by calling XML::Document.import.",
+    assert_equal(" Nodes belong to different documents.  You must first import the node by calling LibXML::XML::Document.import.",
                  error.to_s)
 
     doc2.root << doc2.import(doc1.root)
@@ -105,16 +105,16 @@ class TestDocument < Minitest::Test
   end
 
   def test_import_node
-    doc1 = XML::Parser.string('<nums><one></one></nums>').parse
-    doc2 = XML::Parser.string('<nums><two></two></nums>').parse
+    doc1 = LibXML::XML::Parser.string('<nums><one></one></nums>').parse
+    doc2 = LibXML::XML::Parser.string('<nums><two></two></nums>').parse
 
     node = doc1.root.child
 
-    error = assert_raises(XML::Error) do
+    error = assert_raises(LibXML::XML::Error) do
       doc2.root << node
     end
 
-    assert_equal(" Nodes belong to different documents.  You must first import the node by calling XML::Document.import.",
+    assert_equal(" Nodes belong to different documents.  You must first import the node by calling LibXML::XML::Document.import.",
                  error.to_s)
 
     doc2.root << doc2.import(node)
@@ -122,4 +122,11 @@ class TestDocument < Minitest::Test
     assert_equal("<nums><two/><one/></nums>",
                  doc2.root.to_s(:indent => false))
   end
+
+  def test_nonet
+    xml_string = '<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
+    xml = LibXML::XML::Document.string(xml_string, options: LibXML::XML::Parser::Options::NONET)
+    file = File.join(File.dirname(__FILE__), 'model/atom.xml')
+    schema_document = LibXML::XML::Document.file(file, options: LibXML::XML::Parser::Options::NONET)
+  end
 end