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

data/test/test_parser_context.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 
-require File.expand_path('../test_helper', __FILE__)
+require_relative './test_helper'
 
 
 class TestParserContext < Minitest::Test
@@ -12,9 +12,9 @@ class TestParserContext < Minitest::Test
       </bands>
     EOS
 
-    context = XML::Parser::Context.string(xml)
-    assert_instance_of(XML::Parser::Context, context)
-    assert_equal(XML::Encoding::NONE, context.encoding)
+    context = LibXML::XML::Parser::Context.string(xml)
+    assert_instance_of(LibXML::XML::Parser::Context, context)
+    assert_equal(LibXML::XML::Encoding::NONE, context.encoding)
     assert_nil(context.base_uri)
   end
 
@@ -26,11 +26,11 @@ class TestParserContext < Minitest::Test
       </bands>
     EOS
 
-    context = XML::Parser::Context.string(xml)
-    assert_equal(XML::Encoding::NONE, context.encoding)
+    context = LibXML::XML::Parser::Context.string(xml)
+    assert_equal(LibXML::XML::Encoding::NONE, context.encoding)
 
-    context.encoding = XML::Encoding::ISO_8859_1
-    assert_equal(XML::Encoding::ISO_8859_1, context.encoding)
+    context.encoding = LibXML::XML::Encoding::ISO_8859_1
+    assert_equal(LibXML::XML::Encoding::ISO_8859_1, context.encoding)
   end
 
   def test_invalid_encoding
@@ -41,7 +41,7 @@ class TestParserContext < Minitest::Test
       </bands>
     EOS
 
-    context = XML::Parser::Context.string(xml)
+    context = LibXML::XML::Parser::Context.string(xml)
 
     error = assert_raises(ArgumentError) do
       context.encoding = -999
@@ -57,7 +57,7 @@ class TestParserContext < Minitest::Test
       </bands>
     EOS
 
-    context = XML::Parser::Context.string(xml)
+    context = LibXML::XML::Parser::Context.string(xml)
     assert_nil(context.base_uri)
 
     context.base_uri = 'http://libxml.rubyforge.org'
@@ -66,25 +66,25 @@ class TestParserContext < Minitest::Test
 
   def test_string_empty
     error = assert_raises(TypeError) do
-      XML::Parser::Context.string(nil)
+      LibXML::XML::Parser::Context.string(nil)
     end
     assert_equal("wrong argument type nil (expected String)", error.to_s)
 
     error = assert_raises(ArgumentError) do
-      XML::Parser::Context.string('')
+      LibXML::XML::Parser::Context.string('')
     end
     assert_equal("Must specify a string with one or more characters", error.to_s)
   end
 
   def test_well_formed
-    parser = XML::Parser.string("<abc/>")
+    parser = LibXML::XML::Parser.string("<abc/>")
     parser.parse
     assert(parser.context.well_formed?)
   end
 
   def test_not_well_formed
-    parser = XML::Parser.string("<abc>")
-    assert_raises(XML::Error) do
+    parser = LibXML::XML::Parser.string("<abc>")
+    assert_raises(LibXML::XML::Error) do
       parser.parse
     end
     assert(!parser.context.well_formed?)
@@ -92,34 +92,34 @@ class TestParserContext < Minitest::Test
 
   def test_version_info
     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)
     assert_nil(parser.context.version)
     parser.parse
     assert_equal("1.0", parser.context.version)
   end
 
   def test_depth
-    context = XML::Parser::Context.new
+    context = LibXML::XML::Parser::Context.new
     assert_instance_of(Integer, context.depth)
   end
 
   def test_disable_sax
-    context = XML::Parser::Context.new
+    context = LibXML::XML::Parser::Context.new
     assert(!context.disable_sax?)
   end
 
   def test_docbook
-    context = XML::Parser::Context.new
+    context = LibXML::XML::Parser::Context.new
     assert(!context.docbook?)
   end
 
   def test_html
-    context = XML::Parser::Context.new
+    context = LibXML::XML::Parser::Context.new
     assert(!context.html?)
   end
 
   def test_keep_blanks
-    context = XML::Parser::Context.new
+    context = LibXML::XML::Parser::Context.new
     if context.keep_blanks?
       assert_instance_of(TrueClass, context.keep_blanks?)
     else
@@ -134,7 +134,7 @@ class TestParserContext < Minitest::Test
   end
 
   def test_replace_entities
-    context = XML::Parser::Context.new
+    context = LibXML::XML::Parser::Context.new
     assert(!context.replace_entities?)
 
 #    context.options = 1
@@ -148,24 +148,24 @@ class TestParserContext < Minitest::Test
   end
 
   def test_space_depth
-    context = XML::Parser::Context.new
+    context = LibXML::XML::Parser::Context.new
     assert_equal(1, context.space_depth)
   end
 
   def test_subset_external
-    context = XML::Parser::Context.new
+    context = LibXML::XML::Parser::Context.new
     assert(!context.subset_external?)
   end
 
   def test_data_directory_get
-    context = XML::Parser::Context.new
+    context = LibXML::XML::Parser::Context.new
     assert_nil(context.data_directory)
   end
 
   def test_parse_error
-    xp = XML::Parser.string('<foo><bar/></foz>')
+    xp = LibXML::XML::Parser.string('<foo><bar/></foz>')
 
-    assert_raises(XML::Error) do
+    assert_raises(LibXML::XML::Error) do
       xp.parse
     end
 
@@ -175,7 +175,7 @@ class TestParserContext < Minitest::Test
     assert_equal(0, context.depth)
     assert_equal(true, context.disable_sax?)
     assert_equal(false, context.docbook?)
-    assert_equal(XML::Encoding::NONE, context.encoding)
+    assert_equal(LibXML::XML::Encoding::NONE, context.encoding)
     assert_equal(76, context.errno)
     assert_equal(false, context.html?)
     assert_equal(5, context.io_max_num_streams)

data/test/test_properties.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 
-require File.expand_path('../test_helper', __FILE__)
+require_relative './test_helper'
 
 
 # attributes is deprecated - use attributes instead.
@@ -8,7 +8,7 @@ require File.expand_path('../test_helper', __FILE__)
 
 class Testattributes < Minitest::Test
   def setup()
-    xp = XML::Parser.string('<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>')
+    xp = LibXML::XML::Parser.string('<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>')
     @doc = xp.parse
   end
 
@@ -19,20 +19,20 @@ class Testattributes < Minitest::Test
   def test_traversal
     attributes = @doc.root.attributes
     
-    assert_instance_of(XML::Attributes, attributes)
+    assert_instance_of(LibXML::XML::Attributes, attributes)
     attribute = attributes.first
     assert_equal('uga', attribute.name)
     assert_equal('booga', attribute.value)
 
     attribute = attribute.next
-    assert_instance_of(XML::Attr, attribute)
+    assert_instance_of(LibXML::XML::Attr, attribute)
     assert_equal('foo', attribute.name)
     assert_equal('bar', attribute.value)
   end
   
   def test_no_attributes
     attributes = @doc.root.child.attributes
-    assert_instance_of(XML::Attributes, attributes)
+    assert_instance_of(LibXML::XML::Attributes, attributes)
     assert_equal(0, attributes.length)
   end
 end

data/test/test_reader.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 
-require File.expand_path('../test_helper', __FILE__)
+require_relative './test_helper'
 require 'stringio'
 
 class TestReader < Minitest::Test
@@ -19,60 +19,60 @@ class TestReader < Minitest::Test
     assert(!reader.read)
 
     # Check what was read
-    expected = [XML::Reader::TYPE_PROCESSING_INSTRUCTION,
-                XML::Reader::TYPE_ELEMENT,
-                XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
-                XML::Reader::TYPE_COMMENT,
-                XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
-                XML::Reader::TYPE_ELEMENT,
-                XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
-                XML::Reader::TYPE_ELEMENT,
-                XML::Reader::TYPE_CDATA,
-                XML::Reader::TYPE_END_ELEMENT,
-                XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
-                XML::Reader::TYPE_ELEMENT,
-                XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
-                XML::Reader::TYPE_ELEMENT,
-                XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
-                XML::Reader::TYPE_ELEMENT,
-                XML::Reader::TYPE_TEXT,
-                XML::Reader::TYPE_END_ELEMENT,
-                XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
-                XML::Reader::TYPE_END_ELEMENT,
-                XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
-                XML::Reader::TYPE_END_ELEMENT,
-                XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
-                XML::Reader::TYPE_END_ELEMENT,
-                XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
-                XML::Reader::TYPE_END_ELEMENT]
+    expected = [LibXML::XML::Reader::TYPE_PROCESSING_INSTRUCTION,
+                LibXML::XML::Reader::TYPE_ELEMENT,
+                LibXML::XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
+                LibXML::XML::Reader::TYPE_COMMENT,
+                LibXML::XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
+                LibXML::XML::Reader::TYPE_ELEMENT,
+                LibXML::XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
+                LibXML::XML::Reader::TYPE_ELEMENT,
+                LibXML::XML::Reader::TYPE_CDATA,
+                LibXML::XML::Reader::TYPE_END_ELEMENT,
+                LibXML::XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
+                LibXML::XML::Reader::TYPE_ELEMENT,
+                LibXML::XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
+                LibXML::XML::Reader::TYPE_ELEMENT,
+                LibXML::XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
+                LibXML::XML::Reader::TYPE_ELEMENT,
+                LibXML::XML::Reader::TYPE_TEXT,
+                LibXML::XML::Reader::TYPE_END_ELEMENT,
+                LibXML::XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
+                LibXML::XML::Reader::TYPE_END_ELEMENT,
+                LibXML::XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
+                LibXML::XML::Reader::TYPE_END_ELEMENT,
+                LibXML::XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
+                LibXML::XML::Reader::TYPE_END_ELEMENT,
+                LibXML::XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
+                LibXML::XML::Reader::TYPE_END_ELEMENT]
 
     assert_equal(expected, node_types)
   end
 
   def test_document
-    reader = XML::Reader.document(XML::Document.file(XML_FILE))
+    reader = LibXML::XML::Reader.document(LibXML::XML::Document.file(XML_FILE))
     verify_simple(reader)
   end
 
   def test_file
-    reader = XML::Reader.file(XML_FILE)
+    reader = LibXML::XML::Reader.file(XML_FILE)
     verify_simple(reader)
   end
 
   def test_invalid_file
-    assert_raises(XML::Error) do
-      XML::Reader.file('/does/not/exist')
+    assert_raises(LibXML::XML::Error) do
+      LibXML::XML::Reader.file('/does/not/exist')
     end
   end
 
   def test_string
-    reader = XML::Reader.string(File.read(XML_FILE))
+    reader = LibXML::XML::Reader.string(File.read(XML_FILE))
     verify_simple(reader)
   end
 
   def test_io
     File.open(XML_FILE, 'rb') do |io|
-      reader = XML::Reader.io(io)
+      reader = LibXML::XML::Reader.io(io)
       verify_simple(reader)
     end
   end
@@ -81,7 +81,7 @@ class TestReader < Minitest::Test
     # Test that the reader keeps a reference
     # to the io object
     file = File.open(XML_FILE, 'rb')
-    reader = XML::Reader.io(file)
+    reader = LibXML::XML::Reader.io(file)
     file = nil
     GC.start
     assert(reader.read)
@@ -90,21 +90,21 @@ class TestReader < Minitest::Test
   def test_string_io
     data = File.read(XML_FILE)
     string_io = StringIO.new(data)
-    reader = XML::Reader.io(string_io)
+    reader = LibXML::XML::Reader.io(string_io)
     verify_simple(reader)
   end
 
   def test_error
-    reader = XML::Reader.string('<foo blah')
+    reader = LibXML::XML::Reader.string('<foo blah')
 
-    error = assert_raises(XML::Error) do
+    error = assert_raises(LibXML::XML::Error) do
       reader.read
     end
     assert_equal("Fatal error: Couldn't find end of Start Tag foo at :1.", error.to_s)
   end
 
   def test_attr
-    parser = XML::Reader.string("<foo x='1' y='2'/>")
+    parser = LibXML::XML::Reader.string("<foo x='1' y='2'/>")
     assert(parser.read)
     assert_equal('foo', parser.name)
     assert_equal('1', parser['x'])
@@ -116,7 +116,7 @@ class TestReader < Minitest::Test
   end
 
   def test_move_attr
-      reader = XML::Reader.string('<root xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xhtml="http://www.w3.org/1999/xhtml"><link xml:id="abc" xlink:href="def" xhtml:class="ghi" bar="jkl" /></root>')
+      reader = LibXML::XML::Reader.string('<root xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xhtml="http://www.w3.org/1999/xhtml"><link xml:id="abc" xlink:href="def" xhtml:class="ghi" bar="jkl" /></root>')
       assert(reader.read) # <root/>
       assert(reader.read) # <link/>
 
@@ -134,7 +134,7 @@ class TestReader < Minitest::Test
   end
 
   def test_get_attr
-      reader = XML::Reader.string('<root xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xhtml="http://www.w3.org/1999/xhtml"><link xml:id="abc" xlink:href="def" xhtml:class="ghi" bar="jkl" /></root>')
+      reader = LibXML::XML::Reader.string('<root xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xhtml="http://www.w3.org/1999/xhtml"><link xml:id="abc" xlink:href="def" xhtml:class="ghi" bar="jkl" /></root>')
       assert(reader.read) # <root/>
       assert(reader.read) # <link/>
 
@@ -148,24 +148,24 @@ class TestReader < Minitest::Test
   end
 
   def test_value
-    parser = XML::Reader.string("<foo><bar>1</bar><bar>2</bar><bar>3</bar></foo>")
+    parser = LibXML::XML::Reader.string("<foo><bar>1</bar><bar>2</bar><bar>3</bar></foo>")
     assert(parser.read)
     assert_equal('foo', parser.name)
     assert_nil(parser.value)
     3.times do |i|
       assert(parser.read)
-      assert_equal(XML::Reader::TYPE_ELEMENT, parser.node_type)
+      assert_equal(LibXML::XML::Reader::TYPE_ELEMENT, parser.node_type)
       assert_equal('bar', parser.name)
       assert(parser.read)
-      assert_equal(XML::Reader::TYPE_TEXT, parser.node_type)
+      assert_equal(LibXML::XML::Reader::TYPE_TEXT, parser.node_type)
       assert_equal((i + 1).to_s, parser.value)
       assert(parser.read)
-      assert_equal(XML::Reader::TYPE_END_ELEMENT, parser.node_type)
+      assert_equal(LibXML::XML::Reader::TYPE_END_ELEMENT, parser.node_type)
     end
   end
 
   def test_expand
-    reader = XML::Reader.file(XML_FILE)
+    reader = LibXML::XML::Reader.file(XML_FILE)
     reader.read.to_s
     reader.read
 
@@ -177,7 +177,7 @@ class TestReader < Minitest::Test
   end
 
   def test_expand_find
-    reader = XML::Reader.file(XML_FILE)
+    reader = LibXML::XML::Reader.file(XML_FILE)
     reader.read.to_s
     reader.read
 
@@ -195,7 +195,7 @@ class TestReader < Minitest::Test
   end
 
   def test_expand_invalid
-    reader = XML::Reader.file(XML_FILE)
+    reader = LibXML::XML::Reader.file(XML_FILE)
 
     # Expand a node before one has been read
     node = reader.expand
@@ -203,7 +203,7 @@ class TestReader < Minitest::Test
   end
 
   def test_expand_should_be_invalid
-    reader = XML::Reader.file(XML_FILE)
+    reader = LibXML::XML::Reader.file(XML_FILE)
 
     # Read a couple of nodes
     reader.read
@@ -222,7 +222,7 @@ class TestReader < Minitest::Test
 
   def test_expand_incorrectly_use_returned_node
     file = File.join(File.dirname(__FILE__), 'model/cwm_1_0.xml')
-    reader = XML::Reader.file(file)
+    reader = LibXML::XML::Reader.file(file)
 
     nodes = Array.new
     while reader.read
@@ -242,27 +242,27 @@ class TestReader < Minitest::Test
   end
 
   def test_mode
-    reader = XML::Reader.string('<xml/>')
-    assert_equal(XML::Reader::MODE_INITIAL, reader.read_state)
+    reader = LibXML::XML::Reader.string('<xml/>')
+    assert_equal(LibXML::XML::Reader::MODE_INITIAL, reader.read_state)
     reader.read
-    assert_equal(XML::Reader::MODE_EOF, reader.read_state)
+    assert_equal(LibXML::XML::Reader::MODE_EOF, reader.read_state)
   end
 
   def test_bytes_consumed
-    reader = XML::Reader.file(XML_FILE)
+    reader = LibXML::XML::Reader.file(XML_FILE)
     reader.read
-    assert_equal(416, reader.byte_consumed)
+    assert_equal(428, reader.byte_consumed)
   end
 
   def test_node
-    XML.default_line_numbers = true
-    reader = XML::Reader.file(XML_FILE)
+    LibXML::XML.default_line_numbers = true
+    reader = LibXML::XML::Reader.file(XML_FILE)
 
     # first try to get a node
     assert_nil(reader.node)
 
     reader.read
-    assert_instance_of(XML::Node, reader.node)
+    assert_instance_of(LibXML::XML::Node, reader.node)
   end
 
   def test_base_uri
@@ -270,7 +270,7 @@ class TestReader < Minitest::Test
     # ö - c3 b6 in hex, \303\266 in octal
     # ü - c3 bc in hex, \303\274 in octal
     xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?><bands genre=\"metal\">\n  <m\303\266tley_cr\303\274e country=\"us\">An American heavy metal band formed in Los Angeles, California in 1981.</m\303\266tley_cr\303\274e>\n  <iron_maiden country=\"uk\">British heavy metal band formed in 1975.</iron_maiden>\n</bands>"
-    reader = XML::Reader.string(xml, :base_uri => "http://libxml.rubyforge.org")
+    reader = LibXML::XML::Reader.string(xml, :base_uri => "http://libxml.rubyforge.org")
 
     reader.read
     assert_equal(reader.base_uri, "http://libxml.rubyforge.org")
@@ -287,22 +287,22 @@ class TestReader < Minitest::Test
     EOS
 
     # Parse normally
-    reader = XML::Reader.string(xml)
+    reader = LibXML::XML::Reader.string(xml)
     reader.read # foo
     reader.read # test
     reader.read # text
     reader.read # cdata
     reader.read # cdata-section
-    assert_equal(XML::Node::CDATA_SECTION_NODE, reader.node_type)
+    assert_equal(LibXML::XML::Node::CDATA_SECTION_NODE, reader.node_type)
 
     # Convert cdata section to text
-    reader = XML::Reader.string(xml, :options => XML::Parser::Options::NOCDATA)
+    reader = LibXML::XML::Reader.string(xml, :options => LibXML::XML::Parser::Options::NOCDATA)
     reader.read # foo
     reader.read # test
     reader.read # text
     reader.read # cdata
     reader.read # cdata-section
-    assert_equal(XML::Node::TEXT_NODE, reader.node_type)
+    assert_equal(LibXML::XML::Node::TEXT_NODE, reader.node_type)
   end
 
   def test_encoding
@@ -311,24 +311,19 @@ class TestReader < Minitest::Test
     # ü - fc in hex, \374 in octal
     xml = "<?xml version=\"1.0\" encoding=\"iso-8859-1\"?><bands genre=\"metal\">\n  <m\366tley_cr\374e country=\"us\">An American heavy metal band formed in Los Angeles, California in 1981.</m\366tley_cr\374e>\n  <iron_maiden country=\"uk\">British heavy metal band formed in 1975.</iron_maiden>\n</bands>"
 
-    reader = XML::Reader.string(xml, :encoding => XML::Encoding::ISO_8859_1)
+    reader = LibXML::XML::Reader.string(xml, :encoding => LibXML::XML::Encoding::ISO_8859_1)
     reader.read
 
-    if defined?(Encoding)
-      assert_equal(Encoding::ISO8859_1, reader.read_outer_xml.encoding)
-      assert_equal(Encoding::ISO8859_1, reader.read_inner_xml.encoding)
-      assert_equal(Encoding::ISO8859_1, reader.read_string.encoding)
-
-      assert_equal("<bands genre=\"metal\">\n  <m\xC3\xB6tley_cr\xC3\xBCe country=\"us\">An American heavy metal band formed in Los Angeles, California in 1981.</m\xC3\xB6tley_cr\xC3\xBCe>\n  <iron_maiden country=\"uk\">British heavy metal band formed in 1975.</iron_maiden>\n</bands>".force_encoding(Encoding::ISO8859_1),
-                   reader.read_outer_xml)
-      assert_equal("\n  <m\xC3\xB6tley_cr\xC3\xBCe country=\"us\">An American heavy metal band formed in Los Angeles, California in 1981.</m\xC3\xB6tley_cr\xC3\xBCe>\n  <iron_maiden country=\"uk\">British heavy metal band formed in 1975.</iron_maiden>\n".force_encoding(Encoding::ISO8859_1),
-                   reader.read_inner_xml)
-      assert_equal("\n  An American heavy metal band formed in Los Angeles, California in 1981.\n  British heavy metal band formed in 1975.\n".force_encoding(Encoding::ISO8859_1),
-                   reader.read_string)
-    else
-      assert_equal("<bands genre=\"metal\">\n  <m\303\266tley_cr\303\274e country=\"us\">An American heavy metal band formed in Los Angeles, California in 1981.</m\303\266tley_cr\303\274e>\n  <iron_maiden country=\"uk\">British heavy metal band formed in 1975.</iron_maiden>\n</bands>",
-                   reader.read_outer_xml)
-    end
+    assert_equal(Encoding::ISO8859_1, reader.read_outer_xml.encoding)
+    assert_equal(Encoding::ISO8859_1, reader.read_inner_xml.encoding)
+    assert_equal(Encoding::ISO8859_1, reader.read_string.encoding)
+
+    assert_equal("<bands genre=\"metal\">\n  <m\xC3\xB6tley_cr\xC3\xBCe country=\"us\">An American heavy metal band formed in Los Angeles, California in 1981.</m\xC3\xB6tley_cr\xC3\xBCe>\n  <iron_maiden country=\"uk\">British heavy metal band formed in 1975.</iron_maiden>\n</bands>".force_encoding(Encoding::ISO8859_1),
+                 reader.read_outer_xml)
+    assert_equal("\n  <m\xC3\xB6tley_cr\xC3\xBCe country=\"us\">An American heavy metal band formed in Los Angeles, California in 1981.</m\xC3\xB6tley_cr\xC3\xBCe>\n  <iron_maiden country=\"uk\">British heavy metal band formed in 1975.</iron_maiden>\n".force_encoding(Encoding::ISO8859_1),
+                 reader.read_inner_xml)
+    assert_equal("\n  An American heavy metal band formed in Los Angeles, California in 1981.\n  British heavy metal band formed in 1975.\n".force_encoding(Encoding::ISO8859_1),
+                 reader.read_string)
   end
 
   def test_invalid_encoding
@@ -337,8 +332,8 @@ class TestReader < Minitest::Test
     # ü - fc in hex, \374 in octal
     xml = "<bands genre=\"metal\">\n  <m\366tley_cr\374e country=\"us\">An American heavy metal band formed in Los Angeles, California in 1981.</m\366tley_cr\374e>\n  <iron_maiden country=\"uk\">British heavy metal band formed in 1975.</iron_maiden>\n</bands>"
 
-    reader = XML::Reader.string(xml)
-    error = assert_raises(XML::Error) do
+    reader = LibXML::XML::Reader.string(xml)
+    error = assert_raises(LibXML::XML::Error) do
       reader.read
     end
 
@@ -348,10 +343,10 @@ class TestReader < Minitest::Test
   end
 
   def test_file_encoding
-    reader = XML::Reader.file(XML_FILE)
+    reader = LibXML::XML::Reader.file(XML_FILE)
     reader.read
-    assert_equal(XML::Encoding::UTF_8, reader.encoding)
-    assert_equal(Encoding::UTF_8, reader.value.encoding) if defined?(Encoding)
+    assert_equal(LibXML::XML::Encoding::UTF_8, reader.encoding)
+    assert_equal(Encoding::UTF_8, reader.value.encoding)
   end
 
   def test_string_encoding
@@ -359,10 +354,10 @@ class TestReader < Minitest::Test
     # ö - f6 in hex, \366 in octal
     # ü - fc in hex, \374 in octal
     xml = "<bands genre=\"metal\">\n  <m\366tley_cr\374e country=\"us\">An American heavy metal band formed in Los Angeles, California in 1981.</m\366tley_cr\374e>\n  <iron_maiden country=\"uk\">British heavy metal band formed in 1975.</iron_maiden>\n</bands>"
-    reader = XML::Reader.string(xml, :encoding => XML::Encoding::ISO_8859_1)
+    reader = LibXML::XML::Reader.string(xml, :encoding => LibXML::XML::Encoding::ISO_8859_1)
     reader.read
 
     # Encoding is always null for strings, very annoying!
-    assert_equal(reader.encoding, XML::Encoding::NONE)
+    assert_equal(reader.encoding, LibXML::XML::Encoding::NONE)
   end
 end