libxml-ruby 3.1.0-x64-mingw32 → 3.2.0-x64-mingw32

data/test/test_node_cdata.rb

@@ -1,46 +1,46 @@
 # encoding: UTF-8
 
-require File.expand_path('../test_helper', __FILE__)
+require_relative './test_helper'
 
 class CDataCommentTest < Minitest::Test
   def setup
-    xp = XML::Parser.string('<root></root>')
+    xp = LibXML::XML::Parser.string('<root></root>')
     @doc = xp.parse
-    assert_instance_of(XML::Document, @doc)
+    assert_instance_of(LibXML::XML::Document, @doc)
     @root = @doc.root
   end
 
   def test_node_type
-    cnode = XML::Node.new_cdata('test cdata')
-    assert_equal(XML::Node::CDATA_SECTION_NODE, cnode.node_type)
+    cnode = LibXML::XML::Node.new_cdata('test cdata')
+    assert_equal(LibXML::XML::Node::CDATA_SECTION_NODE, cnode.node_type)
   end
 
   def test_add_cdata
-    @root << XML::Node.new_cdata('mycdata')
+    @root << LibXML::XML::Node.new_cdata('mycdata')
     assert_equal '<root><![CDATA[mycdata]]></root>',
       @root.to_s.gsub(/\n\s*/,'')
   end
 
   def test_add_cdata_2
-    @root << XML::Node.new_cdata('mycdata')
+    @root << LibXML::XML::Node.new_cdata('mycdata')
     assert_equal 'cdata',
     @root.child.node_type_name
   end
 
   def test_add_cdata_3
-    @root << el = XML::Node.new_cdata('mycdata')
+    @root << el = LibXML::XML::Node.new_cdata('mycdata')
     el << "_this_is_added"
     assert_equal '<root><![CDATA[mycdata_this_is_added]]></root>',
       @root.to_s.gsub(/\n\s*/,'')
   end
   
   def test_attributes
-    cnode = XML::Node.new_cdata('test cdata')
+    cnode = LibXML::XML::Node.new_cdata('test cdata')
     assert_equal(0, cnode.attributes.length)
   end
   
   def test_set_cdata_attribute
-    cnode = XML::Node.new_cdata('test cdata')
+    cnode = LibXML::XML::Node.new_cdata('test cdata')
     
     # Can't create attributes on non-element nodes
     assert_raises(ArgumentError) do

data/test/test_node_comment.rb

@@ -1,30 +1,30 @@
 # encoding: UTF-8
 
-require File.expand_path('../test_helper', __FILE__)
+require_relative './test_helper'
 
 
 class NodeCommentTest < Minitest::Test
   def setup
-    xp = XML::Parser.string('<root></root>')
+    xp = LibXML::XML::Parser.string('<root></root>')
     @doc = xp.parse
-    assert_instance_of(XML::Document, @doc)
+    assert_instance_of(LibXML::XML::Document, @doc)
     @root = @doc.root
   end
 
   def test_libxml_node_add_comment_01
-    @root << XML::Node.new_comment('mycomment')
+    @root << LibXML::XML::Node.new_comment('mycomment')
     assert_equal '<root><!--mycomment--></root>',
       @root.to_s.gsub(/\n\s*/,'')
   end
 
   def test_libxml_node_add_comment_02
-    @root << XML::Node.new_comment('mycomment')
+    @root << LibXML::XML::Node.new_comment('mycomment')
     assert_equal 'comment',
     @root.child.node_type_name
   end
 
   def test_libxml_node_add_comment_03
-    @root << el = XML::Node.new_comment('mycomment')
+    @root << el = LibXML::XML::Node.new_comment('mycomment')
     el << "_this_is_added"
     assert_equal '<root><!--mycomment_this_is_added--></root>',
     @root.to_s.gsub(/\n\s*/,'')

data/test/test_node_copy.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 
-require File.expand_path('../test_helper', __FILE__)
+require_relative './test_helper'
 
 # see mailing list archive
 # [libxml-devel] Segmentation fault when add the cloned/copied node
@@ -15,7 +15,7 @@ class TestNodeCopy < Minitest::Test
       </body></html>
     STR
 
-    doc = XML::Parser.string(str).parse
+    doc = LibXML::XML::Parser.string(str).parse
 
     xpath = "//div"
     @div1 = doc.find(xpath).to_a[0]

data/test/test_node_edit.rb

@@ -1,10 +1,10 @@
 # encoding: UTF-8
 
-require File.expand_path('../test_helper', __FILE__)
+require_relative './test_helper'
 
 class TestNodeEdit < Minitest::Test
   def setup
-    xp = XML::Parser.string('<test><num>one</num><num>two</num><num>three</num></test>')
+    xp = LibXML::XML::Parser.string('<test><num>one</num><num>two</num><num>three</num></test>')
     @doc = xp.parse
   end
 
@@ -25,37 +25,37 @@ class TestNodeEdit < Minitest::Test
   end
 
   def test_add_next_01
-    first_node.next = XML::Node.new('num', 'one-and-a-half')
+    first_node.next = LibXML::XML::Node.new('num', 'one-and-a-half')
     assert_equal('<test><num>one</num><num>one-and-a-half</num><num>two</num><num>three</num></test>',
                  @doc.root.to_s.gsub(/\n\s*/,''))
   end
 
   def test_add_next_02
-    second_node.next = XML::Node.new('num', 'two-and-a-half')
+    second_node.next = LibXML::XML::Node.new('num', 'two-and-a-half')
     assert_equal('<test><num>one</num><num>two</num><num>two-and-a-half</num><num>three</num></test>',
                  @doc.root.to_s.gsub(/\n\s*/,''))
   end
 
   def test_add_next_03
-    third_node.next = XML::Node.new('num', 'four')
+    third_node.next = LibXML::XML::Node.new('num', 'four')
     assert_equal '<test><num>one</num><num>two</num><num>three</num><num>four</num></test>',
       @doc.root.to_s.gsub(/\n\s*/,'')
   end
 
   def test_add_prev_01
-    first_node.prev = XML::Node.new('num', 'half')
+    first_node.prev = LibXML::XML::Node.new('num', 'half')
     assert_equal '<test><num>half</num><num>one</num><num>two</num><num>three</num></test>',
       @doc.root.to_s.gsub(/\n\s*/,'')
   end
 
   def test_add_prev_02
-    second_node.prev = XML::Node.new('num', 'one-and-a-half')
+    second_node.prev = LibXML::XML::Node.new('num', 'one-and-a-half')
     assert_equal '<test><num>one</num><num>one-and-a-half</num><num>two</num><num>three</num></test>',
       @doc.root.to_s.gsub(/\n\s*/,'')
   end
 
   def test_add_prev_03
-    third_node.prev = XML::Node.new('num', 'two-and-a-half')
+    third_node.prev = LibXML::XML::Node.new('num', 'two-and-a-half')
     assert_equal '<test><num>one</num><num>two</num><num>two-and-a-half</num><num>three</num></test>',
       @doc.root.to_s.gsub(/\n\s*/,'')
   end
@@ -67,7 +67,7 @@ class TestNodeEdit < Minitest::Test
   end
 
   def test_remove_node_gc
-    xp = XML::Parser.string('<test><num>one</num><num>two</num><num>three</num></test>')
+    xp = LibXML::XML::Parser.string('<test><num>one</num><num>two</num><num>three</num></test>')
     doc = xp.parse
     doc.root.child.remove!
     GC.start
@@ -98,7 +98,7 @@ class TestNodeEdit < Minitest::Test
   end
 
   def test_append_existing_node
-    doc = XML::Parser.string('<top>a<bottom>b<one>first</one><two>second</two>c</bottom>d</top>').parse
+    doc = LibXML::XML::Parser.string('<top>a<bottom>b<one>first</one><two>second</two>c</bottom>d</top>').parse
     node1 = doc.find_first('//two')
 
     doc.root << node1
@@ -107,17 +107,17 @@ class TestNodeEdit < Minitest::Test
   end
 
   def test_wrong_doc
-    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
 
     GC.start
-    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)
   end
 
@@ -127,7 +127,7 @@ class TestNodeEdit < Minitest::Test
 
     # Read in 500 documents
     500.times do
-      documents << XML::Parser.string(File.read(File.join(File.dirname(__FILE__), 'model', 'merge_bug_data.xml'))).parse
+      documents << LibXML::XML::Parser.string(File.read(File.join(File.dirname(__FILE__), 'model', 'merge_bug_data.xml'))).parse
     end
 
     master_doc = documents.shift
@@ -145,7 +145,7 @@ class TestNodeEdit < Minitest::Test
   end
 
   def test_append_chain
-    node = XML::Node.new('foo') << XML::Node.new('bar') << "bars contents"
+    node = LibXML::XML::Node.new('foo') << LibXML::XML::Node.new('bar') << "bars contents"
     assert_equal('<foo><bar/>bars contents</foo>',
                  node.to_s)
   end

data/test/test_node_pi.rb

@@ -1,36 +1,36 @@
 # encoding: UTF-8
 
-require File.expand_path('../test_helper', __FILE__)
+require_relative './test_helper'
 
 class NodePiTest < Minitest::Test
   def setup
-    xp = XML::Parser.string('<root></root>')
+    xp = LibXML::XML::Parser.string('<root></root>')
     @doc = xp.parse
-    assert_instance_of(XML::Document, @doc)
+    assert_instance_of(LibXML::XML::Document, @doc)
     @root = @doc.root
   end
 
   def test_libxml_node_add_pi_01
-    @root << XML::Node.new_pi('mypi')
+    @root << LibXML::XML::Node.new_pi('mypi')
     assert_equal '<root><?mypi?></root>',
       @root.to_s.gsub(/\n\s*/,'')
   end
 
   def test_libxml_node_add_pi_02
-    @root << XML::Node.new_pi('mypi')
+    @root << LibXML::XML::Node.new_pi('mypi')
     assert_equal 'pi',
     @root.child.node_type_name
   end
 
   def test_libxml_node_add_pi_03
-    @root << el = XML::Node.new_pi('mypi')
+    @root << el = LibXML::XML::Node.new_pi('mypi')
     el << "_this_is_added"
     assert_equal '<root><?mypi _this_is_added?></root>',
     @root.to_s.gsub(/\n\s*/,'')
   end
 
   def test_libxml_node_add_pi_04
-    @root << XML::Node.new_pi('mypi','mycontent')
+    @root << LibXML::XML::Node.new_pi('mypi','mycontent')
     assert_equal '<root><?mypi mycontent?></root>',
       @root.to_s.gsub(/\n\s*/,'')
   end

data/test/test_node_text.rb

@@ -1,17 +1,17 @@
 # encoding: UTF-8
 
-require File.expand_path('../test_helper', __FILE__)
+require_relative './test_helper'
 
 class TestTextNode < Minitest::Test
   def test_content
-    node = XML::Node.new_text('testdata')
-    assert_instance_of(XML::Node, node)
+    node = LibXML::XML::Node.new_text('testdata')
+    assert_instance_of(LibXML::XML::Node, node)
     assert_equal('testdata', node.content)
   end
 
   def test_invalid_content
     error = assert_raises(TypeError) do
-      XML::Node.new_text(nil)
+      LibXML::XML::Node.new_text(nil)
     end
     assert_equal('wrong argument type nil (expected String)', error.to_s)
   end
@@ -27,7 +27,7 @@ class TestTextNode < Minitest::Test
 		textnoenc = 'if (a < b || c > d) return "e";'
 		text = "if (a &lt; b || c &gt; d) return \"e\";"
  
-		node = XML::Node.new_text(textnoenc)
+		node = LibXML::XML::Node.new_text(textnoenc)
 		assert node.output_escaping?
 		assert_equal text, node.to_s
 
@@ -46,7 +46,7 @@ class TestTextNode < Minitest::Test
 
 	# Just a sanity check for output escaping.
   def test_output_escaping_sanity
-		node = XML::Node.new_text('testdata')
+		node = LibXML::XML::Node.new_text('testdata')
     assert_equal 'text', node.name
 		assert node.output_escaping?
 

data/test/test_node_write.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 
-require File.expand_path('../test_helper', __FILE__)
+require_relative './test_helper'
 
 class TestNodeWrite < Minitest::Test
   def setup
@@ -8,24 +8,24 @@ class TestNodeWrite < Minitest::Test
   end
   
   def teardown
-    XML.default_keep_blanks = true
+    LibXML::XML.default_keep_blanks = true
     @doc = nil
   end
   
   def load_encoding(name)
-    @encoding = Encoding.find(name) if defined?(Encoding)
+    @encoding = Encoding.find(name)
     @file_name = "model/bands.#{name.downcase}.xml"
 
     # Strip spaces to make testing easier
-    XML.default_keep_blanks = false
+    LibXML::XML.default_keep_blanks = false
     file = File.join(File.dirname(__FILE__), @file_name)
-    @doc = XML::Document.file(file)
+    @doc = LibXML::XML::Document.file(file)
   end
 
   def test_to_s_default
     # Default to_s has indentation
     node = @doc.root
-    assert_equal(Encoding::UTF_8, node.to_s.encoding) if defined?(Encoding)
+    assert_equal(Encoding::UTF_8, node.to_s.encoding)
     assert_equal("<bands genre=\"metal\">\n  <m\303\266tley_cr\303\274e country=\"us\">M\303\266tley Cr\303\274e is an American heavy metal band formed in Los Angeles, California in 1981.</m\303\266tley_cr\303\274e>\n  <iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>",
                  node.to_s)
   end
@@ -33,11 +33,11 @@ class TestNodeWrite < Minitest::Test
   def test_to_s_no_global_indentation
     # No indentation due to global setting
     node = @doc.root
-    XML.indent_tree_output = false
+    LibXML::XML.indent_tree_output = false
     assert_equal("<bands genre=\"metal\">\n<m\303\266tley_cr\303\274e country=\"us\">M\303\266tley Cr\303\274e is an American heavy metal band formed in Los Angeles, California in 1981.</m\303\266tley_cr\303\274e>\n<iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>",
                  node.to_s)
   ensure
-    XML.indent_tree_output = true
+    LibXML::XML.indent_tree_output = true
   end
 
   def test_to_s_no_indentation
@@ -61,23 +61,18 @@ class TestNodeWrite < Minitest::Test
     # UTF8:
     # ö - c3 b6 in hex, \303\266 in octal
     # ü - c3 bc in hex, \303\274 in octal
-    value = node.to_s(:encoding => XML::Encoding::UTF_8)
-    assert_equal(Encoding::UTF_8, node.to_s.encoding) if defined?(Encoding)
+    value = node.to_s(:encoding => LibXML::XML::Encoding::UTF_8)
+    assert_equal(Encoding::UTF_8, node.to_s.encoding)
     assert_equal("<bands genre=\"metal\">\n  <m\303\266tley_cr\303\274e country=\"us\">M\303\266tley Cr\303\274e is an American heavy metal band formed in Los Angeles, California in 1981.</m\303\266tley_cr\303\274e>\n  <iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>",
                  value)
 
     # ISO_8859_1:
     # ö - f6 in hex, \366 in octal
     # ü - fc in hex, \374 in octal
-    value = node.to_s(:encoding => XML::Encoding::ISO_8859_1)
-    if defined?(Encoding)
-      assert_equal(Encoding::ISO8859_1, value.encoding)
-      assert_equal("<bands genre=\"metal\">\n  <m\xF6tley_cr\xFCe country=\"us\">M\xF6tley Cr\xFCe is an American heavy metal band formed in Los Angeles, California in 1981.</m\xF6tley_cr\xFCe>\n  <iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>".force_encoding(Encoding::ISO8859_1),
-                   value)
-    else
-      assert_equal("<bands genre=\"metal\">\n  <m\xF6tley_cr\xFCe country=\"us\">M\xF6tley Cr\xFCe is an American heavy metal band formed in Los Angeles, California in 1981.</m\xF6tley_cr\xFCe>\n  <iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>",
+    value = node.to_s(:encoding => LibXML::XML::Encoding::ISO_8859_1)
+    assert_equal(Encoding::ISO8859_1, value.encoding)
+    assert_equal("<bands genre=\"metal\">\n  <m\xF6tley_cr\xFCe country=\"us\">M\xF6tley Cr\xFCe is an American heavy metal band formed in Los Angeles, California in 1981.</m\xF6tley_cr\xFCe>\n  <iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>".force_encoding(Encoding::ISO8859_1),
                  value)
-    end
 
     # Invalid encoding
     error = assert_raises(ArgumentError) do
@@ -90,14 +85,9 @@ class TestNodeWrite < Minitest::Test
     # Default to_s has indentation
     node = @doc.root
 
-    if defined?(Encoding)
-      assert_equal(Encoding::UTF_8, node.inner_xml.encoding)
-      assert_equal("<m\u00F6tley_cr\u00FCe country=\"us\">M\u00F6tley Cr\u00FCe is an American heavy metal band formed in Los Angeles, California in 1981.</m\u00F6tley_cr\u00FCe><iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>",
-                   node.inner_xml)
-    else
-      assert_equal("<m\303\266tley_cr\303\274e country=\"us\">M\303\266tley Cr\303\274e is an American heavy metal band formed in Los Angeles, California in 1981.</m\303\266tley_cr\303\274e><iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>",
-                   node.inner_xml)
-    end
+    assert_equal(Encoding::UTF_8, node.inner_xml.encoding)
+    assert_equal("<m\u00F6tley_cr\u00FCe country=\"us\">M\u00F6tley Cr\u00FCe is an American heavy metal band formed in Los Angeles, California in 1981.</m\u00F6tley_cr\u00FCe><iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>",
+                 node.inner_xml)
   end
 
   # --- Debug ---

data/test/test_node_xlink.rb

@@ -1,16 +1,16 @@
 # encoding: UTF-8
 
 # $Id$
-require File.expand_path('../test_helper', __FILE__)
+require_relative './test_helper'
 
 
 class TC_XML_Node_XLink < Minitest::Test
   def setup()
-    xp = XML::Parser.string('<ruby_array xmlns:xlink="http://www.w3.org/1999/xlink/namespace/"><fixnum xlink:type="simple">one</fixnum></ruby_array>')
+    xp = LibXML::XML::Parser.string('<ruby_array xmlns:xlink="http://www.w3.org/1999/xlink/namespace/"><fixnum xlink:type="simple">one</fixnum></ruby_array>')
     doc = xp.parse
-    assert_instance_of(XML::Document, doc)
+    assert_instance_of(LibXML::XML::Document, doc)
     @root = doc.root
-    assert_instance_of(XML::Node, @root)
+    assert_instance_of(LibXML::XML::Node, @root)
   end
 
   def teardown()
@@ -19,10 +19,10 @@ class TC_XML_Node_XLink < Minitest::Test
 
   def test_xml_node_xlink()
     for elem in @root.find('fixnum')
-      assert_instance_of(XML::Node, elem)
+      assert_instance_of(LibXML::XML::Node, elem)
       assert_instance_of(TrueClass, elem.xlink?)
       assert_equal("simple", elem.xlink_type_name)
-      assert_equal(XML::Node::XLINK_TYPE_SIMPLE, elem.xlink_type)
+      assert_equal(LibXML::XML::Node::XLINK_TYPE_SIMPLE, elem.xlink_type)
     end
   end
 end

data/test/test_parser.rb

@@ -1,47 +1,47 @@
 # encoding: UTF-8
 
-require File.expand_path('../test_helper', __FILE__)
+require_relative './test_helper'
 require 'stringio'
 
 class TestParser < Minitest::Test
   def setup
-    XML::Error.set_handler(&XML::Error::QUIET_HANDLER)
+    LibXML::XML::Error.set_handler(&LibXML::XML::Error::QUIET_HANDLER)
   end
 
   # -----  Sources  -------
   def test_document
     file = File.expand_path(File.join(File.dirname(__FILE__), 'model/bands.utf-8.xml'))
-    parser = XML::Parser.file(file)
+    parser = LibXML::XML::Parser.file(file)
     doc = parser.parse
 
-    parser = XML::Parser.document(doc)
+    parser = LibXML::XML::Parser.document(doc)
 
     doc = parser.parse
 
-    assert_instance_of(XML::Document, doc)
-    assert_instance_of(XML::Parser::Context, parser.context)
+    assert_instance_of(LibXML::XML::Document, doc)
+    assert_instance_of(LibXML::XML::Parser::Context, parser.context)
   end
 
   def test_nil_document
     error = assert_raises(TypeError) do
-      XML::Parser.document(nil)
+      LibXML::XML::Parser.document(nil)
     end
 
-    assert_equal("Must pass an XML::Document object", error.to_s)
+    assert_equal("Must pass an LibXML::XML::Document object", error.to_s)
   end
 
   def test_file
     file = File.expand_path(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
 
-    parser = XML::Parser.file(file)
+    parser = LibXML::XML::Parser.file(file)
     doc = parser.parse
-    assert_instance_of(XML::Document, doc)
-    assert_instance_of(XML::Parser::Context, parser.context)
+    assert_instance_of(LibXML::XML::Document, doc)
+    assert_instance_of(LibXML::XML::Parser::Context, parser.context)
   end
 
   def test_noexistent_file
-    error = assert_raises(XML::Error) do
-      XML::Parser.file('i_dont_exist.xml')
+    error = assert_raises(LibXML::XML::Error) do
+      LibXML::XML::Parser.file('i_dont_exist.xml')
     end
 
     assert_equal('Warning: failed to load external entity "i_dont_exist.xml".', error.to_s)
@@ -49,7 +49,7 @@ class TestParser < Minitest::Test
 
   def test_nil_file
     error = assert_raises(TypeError) do
-      XML::Parser.file(nil)
+      LibXML::XML::Parser.file(nil)
     end
 
     assert_match(/nil into String/, error.to_s)
@@ -57,15 +57,15 @@ class TestParser < Minitest::Test
 
   def test_file_encoding
     file = File.expand_path(File.join(File.dirname(__FILE__), 'model/bands.utf-8.xml'))
-    parser = XML::Parser.file(file, :encoding => XML::Encoding::ISO_8859_1)
+    parser = LibXML::XML::Parser.file(file, :encoding => LibXML::XML::Encoding::ISO_8859_1)
 
-    error = assert_raises(XML::Error) do
+    error = assert_raises(LibXML::XML::Error) do
       parser.parse
     end
 
     assert(error.to_s.match(/Fatal error: Extra content at the end of the document/))
 
-    parser = XML::Parser.file(file, :encoding => XML::Encoding::UTF_8)
+    parser = LibXML::XML::Parser.file(file, :encoding => LibXML::XML::Encoding::UTF_8)
     doc = parser.parse
     refute_nil(doc)
   end
@@ -73,23 +73,23 @@ class TestParser < Minitest::Test
   def test_file_base_uri
     file = File.expand_path(File.join(File.dirname(__FILE__), 'model/bands.utf-8.xml'))
 
-    parser = XML::Parser.file(file)
+    parser = LibXML::XML::Parser.file(file)
     doc = parser.parse
     assert(doc.child.base_uri.match(/test\/model\/bands.utf-8.xml/))
 
-    parser = XML::Parser.file(file, :base_uri => "http://libxml.org")
+    parser = LibXML::XML::Parser.file(file, :base_uri => "http://libxml.org")
     doc = parser.parse
     assert(doc.child.base_uri.match(/test\/model\/bands.utf-8.xml/))
   end
 
   def test_io
     File.open(File.join(File.dirname(__FILE__), 'model/rubynet.xml')) do |io|
-      parser = XML::Parser.io(io)
-      assert_instance_of(XML::Parser, parser)
+      parser = LibXML::XML::Parser.io(io)
+      assert_instance_of(LibXML::XML::Parser, parser)
 
       doc = parser.parse
-      assert_instance_of(XML::Document, doc)
-      assert_instance_of(XML::Parser::Context, parser.context)
+      assert_instance_of(LibXML::XML::Document, doc)
+      assert_instance_of(LibXML::XML::Parser::Context, parser.context)
     end
   end
 
@@ -97,7 +97,7 @@ class TestParser < Minitest::Test
     # Test that the reader keeps a reference
     # to the io object
     file = File.open(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
-    parser = XML::Parser.io(file)
+    parser = LibXML::XML::Parser.io(file)
     file = nil
     GC.start
     assert(parser.parse)
@@ -105,7 +105,7 @@ class TestParser < Minitest::Test
 
   def test_nil_io
     error = assert_raises(TypeError) do
-      XML::Parser.io(nil)
+      LibXML::XML::Parser.io(nil)
     end
 
     assert_equal("Must pass in an IO object", error.to_s)
@@ -114,22 +114,22 @@ class TestParser < Minitest::Test
   def test_string_io
     data = File.read(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
     string_io = StringIO.new(data)
-    parser = XML::Parser.io(string_io)
+    parser = LibXML::XML::Parser.io(string_io)
 
     doc = parser.parse
-    assert_instance_of(XML::Document, doc)
-    assert_instance_of(XML::Parser::Context, parser.context)
+    assert_instance_of(LibXML::XML::Document, doc)
+    assert_instance_of(LibXML::XML::Parser::Context, parser.context)
   end
 
   def test_string_io_thread
     thread = Thread.new do
       data = File.read(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
       string_io = StringIO.new(data)
-      parser = XML::Parser.io(string_io)
+      parser = LibXML::XML::Parser.io(string_io)
 
       doc = parser.parse
-      assert_instance_of(XML::Document, doc)
-      assert_instance_of(XML::Parser::Context, parser.context)
+      assert_instance_of(LibXML::XML::Document, doc)
+      assert_instance_of(LibXML::XML::Parser::Context, parser.context)
     end
 
     thread.join
@@ -140,17 +140,17 @@ class TestParser < Minitest::Test
   def test_string
     str = '<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
 
-    parser = XML::Parser.string(str)
-    assert_instance_of(XML::Parser, parser)
+    parser = LibXML::XML::Parser.string(str)
+    assert_instance_of(LibXML::XML::Parser, parser)
 
     doc = parser.parse
-    assert_instance_of(XML::Document, doc)
-    assert_instance_of(XML::Parser::Context, parser.context)
+    assert_instance_of(LibXML::XML::Document, doc)
+    assert_instance_of(LibXML::XML::Parser::Context, parser.context)
   end
 
   def test_nil_string
     error = assert_raises(TypeError) do
-      XML::Parser.string(nil)
+      LibXML::XML::Parser.string(nil)
     end
 
     assert_equal("wrong argument type nil (expected String)", error.to_s)
@@ -165,30 +165,30 @@ class TestParser < Minitest::Test
       </test>
     EOS
 
-    XML::default_substitute_entities = false
+    LibXML::XML::default_substitute_entities = false
 
     # Parse normally
-    parser = XML::Parser.string(xml)
+    parser = LibXML::XML::Parser.string(xml)
     doc = parser.parse
     assert_nil(doc.child.base_uri)
 
     # Cdata section should be cdata nodes
     node = doc.find_first('/test/cdata').child
-    assert_equal(XML::Node::CDATA_SECTION_NODE, node.node_type)
+    assert_equal(LibXML::XML::Node::CDATA_SECTION_NODE, node.node_type)
 
     # Entities should not be subtituted
     node = doc.find_first('/test/entity')
     assert_equal('&foo;', node.child.to_s)
 
     # Parse with options
-    parser = XML::Parser.string(xml, :base_uri => 'http://libxml.rubyforge.org',
-                                     :options => XML::Parser::Options::NOCDATA | XML::Parser::Options::NOENT)
+    parser = LibXML::XML::Parser.string(xml, :base_uri => 'http://libxml.rubyforge.org',
+                                     :options => LibXML::XML::Parser::Options::NOCDATA | LibXML::XML::Parser::Options::NOENT)
     doc = parser.parse
     assert_equal(doc.child.base_uri, 'http://libxml.rubyforge.org')
 
     # Cdata section should be text nodes
     node = doc.find_first('/test/cdata').child
-    assert_equal(XML::Node::TEXT_NODE, node.node_type)
+    assert_equal(LibXML::XML::Node::TEXT_NODE, node.node_type)
 
     # Entities should be subtituted
     node = doc.find_first('/test/entity')
@@ -207,9 +207,9 @@ class TestParser < Minitest::Test
     EOS
 
     # Parse as UTF_8
-    parser = XML::Parser.string(xml, :encoding => XML::Encoding::UTF_8)
+    parser = LibXML::XML::Parser.string(xml, :encoding => LibXML::XML::Encoding::UTF_8)
 
-    error = assert_raises(XML::Error) do
+    error = assert_raises(LibXML::XML::Error) do
       parser.parse
     end
 
@@ -217,15 +217,11 @@ class TestParser < Minitest::Test
                  error.to_s)
 
     # Parse as ISO_8859_1:
-    parser = XML::Parser.string(xml, :encoding => XML::Encoding::ISO_8859_1)
+    parser = LibXML::XML::Parser.string(xml, :encoding => LibXML::XML::Encoding::ISO_8859_1)
     doc = parser.parse
     node = doc.find_first('//metal')
-    if defined?(Encoding)
-      assert_equal(Encoding::UTF_8, node.content.encoding)
-      assert_equal("m\303\266tley_cr\303\274e", node.content)
-    else
-      assert_equal("m\303\266tley_cr\303\274e", node.content)
-    end
+    assert_equal(Encoding::UTF_8, node.content.encoding)
+    assert_equal("m\303\266tley_cr\303\274e", node.content)
   end
 
   def test_fd_gc
@@ -235,7 +231,7 @@ class TestParser < Minitest::Test
     # re-open the same doc `limit descriptors` times.
     # If we make it to the end, then we've succeeded,
     # otherwise an exception will be thrown.
-    XML::Error.set_handler {|error|}
+    LibXML::XML::Error.set_handler {|error|}
 
     max_fd = if RUBY_PLATFORM.match(/mswin32|mswin64|mingw/i)
       500
@@ -245,30 +241,30 @@ class TestParser < Minitest::Test
 
     file = File.join(File.dirname(__FILE__), 'model/rubynet.xml')
     max_fd.times do
-       XML::Parser.file(file).parse
+       LibXML::XML::Parser.file(file).parse
     end
-    XML::Error.reset_handler {|error|}
+    LibXML::XML::Error.reset_handler {|error|}
   end
 
   def test_open_many_files
     file = File.expand_path(File.join(File.dirname(__FILE__), 'model/atom.xml'))
     1000.times do
-      XML::Parser.file(file).parse
+      LibXML::XML::Parser.file(file).parse
     end
   end
 
   # -----  Errors  ------
   def test_error
-    error = assert_raises(XML::Error) do
-      XML::Parser.string('<foo><bar/></foz>').parse
+    error = assert_raises(LibXML::XML::Error) do
+      LibXML::XML::Parser.string('<foo><bar/></foz>').parse
     end
 
     refute_nil(error)
-    assert_kind_of(XML::Error, error)
+    assert_kind_of(LibXML::XML::Error, error)
     assert_equal("Fatal error: Opening and ending tag mismatch: foo line 1 and foz at :1.", error.message)
-    assert_equal(XML::Error::PARSER, error.domain)
-    assert_equal(XML::Error::TAG_NAME_MISMATCH, error.code)
-    assert_equal(XML::Error::FATAL, error.level)
+    assert_equal(LibXML::XML::Error::PARSER, error.domain)
+    assert_equal(LibXML::XML::Error::TAG_NAME_MISMATCH, error.code)
+    assert_equal(LibXML::XML::Error::FATAL, error.level)
     assert_nil(error.file)
     assert_equal(1, error.line)
     assert_equal('foo', error.str1)
@@ -280,24 +276,24 @@ class TestParser < Minitest::Test
   end
 
   def test_bad_xml
-    parser = XML::Parser.string('<ruby_array uga="booga" foo="bar"<fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>')
-    error = assert_raises(XML::Error) do
+    parser = LibXML::XML::Parser.string('<ruby_array uga="booga" foo="bar"<fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>')
+    error = assert_raises(LibXML::XML::Error) do
       refute_nil(parser.parse)
     end
 
     refute_nil(error)
-    assert_kind_of(XML::Error, error)
+    assert_kind_of(LibXML::XML::Error, error)
     assert_equal("Fatal error: Extra content at the end of the document at :1.", error.message)
-    assert_equal(XML::Error::PARSER, error.domain)
-    assert_equal(XML::Error::DOCUMENT_END, error.code)
-    assert_equal(XML::Error::FATAL, error.level)
+    assert_equal(LibXML::XML::Error::PARSER, error.domain)
+    assert_equal(LibXML::XML::Error::DOCUMENT_END, error.code)
+    assert_equal(LibXML::XML::Error::FATAL, error.level)
     assert_nil(error.file)
     assert_equal(1, error.line)
     assert_nil(error.str1)
     assert_nil(error.str2)
     assert_nil(error.str3)
     assert_equal(0, error.int1)
-    assert_equal(20, error.int2)
+    assert_equal(34, error.int2)
     assert_nil(error.node)
   end
 
@@ -306,20 +302,20 @@ class TestParser < Minitest::Test
     background_errors = []
 
     begin
-      XML::Error.set_handler do |error|
+      LibXML::XML::Error.set_handler do |error|
         errors << error
       end
-      parser = XML::Parser.string("<moo>")
+      parser = LibXML::XML::Parser.string("<moo>")
 
       thread = Thread.new do
-        XML::Error.set_handler do |error|
+        LibXML::XML::Error.set_handler do |error|
           background_errors << error
         end
         parser.parse rescue nil
       end
       thread.join
     ensure
-      XML::Error.set_handler(&XML::Error::QUIET_HANDLER)
+      LibXML::XML::Error.set_handler(&LibXML::XML::Error::QUIET_HANDLER)
     end
 
     assert_equal(errors.size, 0)