libxml-ruby 2.8.0 → 3.2.3

data/test/test_reader.rb

@@ -0,0 +1,364 @@
+# encoding: UTF-8
+
+require_relative './test_helper'
+require 'stringio'
+
+class TestReader < Minitest::Test
+  XML_FILE = File.join(File.dirname(__FILE__), 'model/atom.xml')
+
+  def verify_simple(reader)
+    node_types = []
+
+    # Read each node
+    26.times do
+      assert(reader.read)
+      node_types << reader.node_type
+    end
+
+    # There are no more nodes
+    assert(!reader.read)
+
+    # Check what was read
+    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 = LibXML::XML::Reader.document(LibXML::XML::Document.file(XML_FILE))
+    verify_simple(reader)
+  end
+
+  def test_file
+    reader = LibXML::XML::Reader.file(XML_FILE)
+    verify_simple(reader)
+  end
+
+  def test_invalid_file
+    assert_raises(LibXML::XML::Error) do
+      LibXML::XML::Reader.file('/does/not/exist')
+    end
+  end
+
+  def test_string
+    reader = LibXML::XML::Reader.string(File.read(XML_FILE))
+    verify_simple(reader)
+  end
+
+  def test_io
+    File.open(XML_FILE, 'rb') do |io|
+      reader = LibXML::XML::Reader.io(io)
+      verify_simple(reader)
+    end
+  end
+
+  def test_io_gc
+    # Test that the reader keeps a reference
+    # to the io object
+    file = File.open(XML_FILE, 'rb')
+    reader = LibXML::XML::Reader.io(file)
+    file = nil
+    GC.start
+    assert(reader.read)
+  end
+
+  def test_string_io
+    data = File.read(XML_FILE)
+    string_io = StringIO.new(data)
+    reader = LibXML::XML::Reader.io(string_io)
+    verify_simple(reader)
+  end
+
+  def test_error
+    reader = LibXML::XML::Reader.string('<foo blah')
+
+    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 = LibXML::XML::Reader.string("<foo x='1' y='2'/>")
+    assert(parser.read)
+    assert_equal('foo', parser.name)
+    assert_equal('1', parser['x'])
+    assert_equal('1', parser[0])
+    assert_equal('2', parser['y'])
+    assert_equal('2', parser[1])
+    assert_nil(parser['z'])
+    assert_nil(parser[2])
+  end
+
+  def test_move_attr
+      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/>
+
+      assert(reader.move_to_attribute_no(1))
+      assert_equal(reader.value, 'def')
+      assert(reader.move_to_attribute_ns('id', 'http://www.w3.org/XML/1998/namespace'))
+      assert_equal(reader.value, 'abc')
+      assert(reader.move_to_attribute('bar'))
+      assert_equal(reader.value, 'jkl')
+
+      # 1 in case of success, -1 in case of error, 0 if not found
+      assert_equal(reader.move_to_attribute_no(12), 0)
+      assert_equal(reader.move_to_attribute('baz'), 0)
+      assert_equal(reader.move_to_attribute_ns('baz', 'http://ruby/namespace'), 0)
+  end
+
+  def test_get_attr
+      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/>
+
+      assert_equal(reader.get_attribute_no(1), 'def')
+      assert_equal(reader.get_attribute_ns('id', 'http://www.w3.org/XML/1998/namespace'), 'abc')
+      assert_equal(reader.get_attribute('bar'), 'jkl')
+
+      assert_nil(reader.get_attribute_no(12))
+      assert_nil(reader.get_attribute('baz'))
+      assert_nil(reader.get_attribute_ns('baz', 'http://ruby/namespace'))
+  end
+
+  def test_value
+    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(LibXML::XML::Reader::TYPE_ELEMENT, parser.node_type)
+      assert_equal('bar', parser.name)
+      assert(parser.read)
+      assert_equal(LibXML::XML::Reader::TYPE_TEXT, parser.node_type)
+      assert_equal((i + 1).to_s, parser.value)
+      assert(parser.read)
+      assert_equal(LibXML::XML::Reader::TYPE_END_ELEMENT, parser.node_type)
+    end
+  end
+
+  def test_expand
+    reader = LibXML::XML::Reader.file(XML_FILE)
+    reader.read.to_s
+    reader.read
+
+    # Read a node
+    node = reader.expand
+    refute_nil(node.doc)
+    assert_equal('feed', node.name)
+    assert_equal(::Encoding::UTF_8, node.name.encoding) if defined?(::Encoding)
+  end
+
+  def test_expand_find
+    reader = LibXML::XML::Reader.file(XML_FILE)
+    reader.read.to_s
+    reader.read
+
+    # Read first node which
+    node = reader.expand
+    assert_equal('feed', node.name)
+
+    # We need to create document to use xpath
+    reader.doc
+
+    # Search for entries
+    entries = node.find('atom:entry', 'atom:http://www.w3.org/2005/Atom')
+
+    assert_equal(1, entries.length)
+  end
+
+  def test_expand_invalid
+    reader = LibXML::XML::Reader.file(XML_FILE)
+
+    # Expand a node before one has been read
+    node = reader.expand
+    assert_nil(node)
+  end
+
+  def test_expand_should_be_invalid
+    reader = LibXML::XML::Reader.file(XML_FILE)
+
+    # Read a couple of nodes
+    reader.read
+    reader.read
+
+    # Expand the node
+    node = reader.expand
+    assert_equal('feed', node.name)
+
+    # Read another node, this makes the last node invalid
+    reader.next
+
+    # The previous node is now invalid - this should be an error but isn't
+    assert_equal('feed', node.name)
+  end
+
+  def test_expand_incorrectly_use_returned_node
+    file = File.join(File.dirname(__FILE__), 'model/cwm_1_0.xml')
+    reader = LibXML::XML::Reader.file(file)
+
+    nodes = Array.new
+    while reader.read
+      node = reader.expand
+      refute_nil(node)
+      refute_nil(node.doc)
+
+      # NOTE - DO NOT do this in real code, these nodes are invalid after the next read. This *will* cause
+      # a segmentation fault next time the garbage collector runs.  The reason is the parent node will be
+      # called in the mark phase, but its underlying xml node will be gone.  Same goes for calling children,
+      # attributes, etc.  You must let go of the expanded node *before* calling xml reader again and
+      # call the garbage collector to be safe.
+      #refute_nil(node.parent)
+      nodes << node
+    end
+    assert(true)
+  end
+
+  def test_mode
+    reader = LibXML::XML::Reader.string('<xml/>')
+    assert_equal(LibXML::XML::Reader::MODE_INITIAL, reader.read_state)
+    reader.read
+    assert_equal(LibXML::XML::Reader::MODE_EOF, reader.read_state)
+  end
+
+  def test_bytes_consumed
+    ending_are_rn = File.binread(XML_FILE).include? "\r\n"
+    reader = LibXML::XML::Reader.file(XML_FILE)
+    reader.read
+    assert_equal(ending_are_rn ? 428 : 416, reader.byte_consumed)
+  end
+
+  def test_node
+    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(LibXML::XML::Node, reader.node)
+  end
+
+  def test_base_uri
+    # UTF8:
+    # ö - 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 = LibXML::XML::Reader.string(xml, :base_uri => "http://libxml.rubyforge.org")
+
+    reader.read
+    assert_equal(reader.base_uri, "http://libxml.rubyforge.org")
+    assert_equal(::Encoding::UTF_8, reader.base_uri.encoding) if defined?(::Encoding)
+  end
+
+  def test_options
+    xml = <<-EOS
+      <!DOCTYPE foo [<!ENTITY foo 'bar'>]>
+      <test>
+        <cdata><![CDATA[something]]></cdata>
+        <entity>&foo;</entity>
+      </test>
+    EOS
+
+    # Parse normally
+    reader = LibXML::XML::Reader.string(xml)
+    reader.read # foo
+    reader.read # test
+    reader.read # text
+    reader.read # cdata
+    reader.read # cdata-section
+    assert_equal(LibXML::XML::Node::CDATA_SECTION_NODE, reader.node_type)
+
+    # Convert cdata section to text
+    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(LibXML::XML::Node::TEXT_NODE, reader.node_type)
+  end
+
+  def test_encoding
+    # ISO_8859_1:
+    # ö - f6 in hex, \366 in octal
+    # ü - 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 = LibXML::XML::Reader.string(xml, :encoding => LibXML::XML::Encoding::ISO_8859_1)
+    reader.read
+
+    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
+    # ISO_8859_1:
+    # ö - 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 = LibXML::XML::Reader.string(xml)
+    error = assert_raises(LibXML::XML::Error) do
+      reader.read
+    end
+
+    assert_equal("Fatal error: Input is not proper UTF-8, indicate encoding !\nBytes: 0xF6 0x74 0x6C 0x65 at :2.",
+                 error.to_s)
+
+  end
+
+  def test_file_encoding
+    reader = LibXML::XML::Reader.file(XML_FILE)
+    reader.read
+    assert_equal(LibXML::XML::Encoding::UTF_8, reader.encoding)
+    assert_equal(Encoding::UTF_8, reader.value.encoding)
+  end
+
+  def test_string_encoding
+    # ISO_8859_1:
+    # ö - 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 = 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, LibXML::XML::Encoding::NONE)
+  end
+end

data/test/test_relaxng.rb

@@ -0,0 +1,53 @@
+# encoding: UTF-8
+
+require_relative './test_helper'
+
+
+class TestRelaxNG < Minitest::Test
+  def setup
+    file = File.join(File.dirname(__FILE__), 'model/shiporder.xml')
+    @doc = LibXML::XML::Document.file(file)
+  end
+  
+  def teardown
+    @doc = nil
+  end
+  
+  def relaxng
+    document = LibXML::XML::Document.file(File.join(File.dirname(__FILE__), 'model/shiporder.rng'))
+    LibXML::XML::RelaxNG.document(document)
+  end
+
+  def test_from_doc
+    assert_instance_of(LibXML::XML::RelaxNG, relaxng)
+  end
+  
+  def test_valid
+    assert(@doc.validate_relaxng(relaxng))
+  end
+  
+  def test_invalid
+    new_node = LibXML::XML::Node.new('invalid', 'this will mess up validation')
+    @doc.root << new_node
+    
+    error = assert_raises(LibXML::XML::Error) do
+      @doc.validate_relaxng(relaxng)
+    end
+
+    refute_nil(error)
+    assert_kind_of(LibXML::XML::Error, error)
+    assert(error.message.match(/Error: Did not expect element invalid there/))
+    assert_equal(LibXML::XML::Error::RELAXNGV, error.domain)
+    assert_equal(LibXML::XML::Error::LT_IN_ATTRIBUTE, error.code)
+    assert_equal(LibXML::XML::Error::ERROR, error.level)
+    assert(error.file.match(/shiporder\.xml/))
+    assert_nil(error.line)
+    assert_equal('invalid', error.str1)
+    assert_nil(error.str2)
+    assert_nil(error.str3)
+    assert_equal(0, error.int1)
+    assert_equal(0, error.int2)
+    refute_nil(error.node)
+    assert_equal('invalid', error.node.name)
+  end
+end

data/test/{tc_sax_parser.rb → test_sax_parser.rb}

@@ -1,17 +1,16 @@
 # encoding: UTF-8
 
-require './test_helper'
+require_relative './test_helper'
 require 'stringio'
-require 'test/unit'
 
 class DocTypeCallback
-  include XML::SaxParser::Callbacks
+  include LibXML::XML::SaxParser::Callbacks
   def on_start_element(element, attributes)
   end
 end
 
 class TestCaseCallbacks
-  include XML::SaxParser::Callbacks
+  include LibXML::XML::SaxParser::Callbacks
 
   attr_accessor :result
 
@@ -68,7 +67,7 @@ class TestCaseCallbacks
   end
 end
 
-class TestSaxParser < Test::Unit::TestCase
+class TestSaxParser < Minitest::Test
   def saxtest_file
     File.join(File.dirname(__FILE__), 'model/atom.xml')
   end
@@ -120,28 +119,28 @@ class TestSaxParser < Test::Unit::TestCase
   end
 
   def test_file
-    parser = XML::SaxParser.file(saxtest_file)
+    parser = LibXML::XML::SaxParser.file(saxtest_file)
     parser.callbacks = TestCaseCallbacks.new
     parser.parse
     verify(parser)
   end
 
   def test_file_no_callbacks
-    parser = XML::SaxParser.file(saxtest_file)
+    parser = LibXML::XML::SaxParser.file(saxtest_file)
     assert_equal true, parser.parse
   end
 
   def test_noexistent_file
-    error = assert_raise(XML::Error) do
-      XML::SaxParser.file('i_dont_exist.xml')
+    error = assert_raises(LibXML::XML::Error) do
+      LibXML::XML::SaxParser.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_raise(TypeError) do
-      XML::SaxParser.file(nil)
+    error = assert_raises(TypeError) do
+      LibXML::XML::SaxParser.file(nil)
     end
 
     assert_match(/nil into String/, error.to_s)
@@ -149,7 +148,7 @@ class TestSaxParser < Test::Unit::TestCase
 
   def test_io
     File.open(saxtest_file) do |file|
-      parser = XML::SaxParser.io(file)
+      parser = LibXML::XML::SaxParser.io(file)
       parser.callbacks = TestCaseCallbacks.new
       parser.parse
       verify(parser)
@@ -157,8 +156,8 @@ class TestSaxParser < Test::Unit::TestCase
   end
 
   def test_nil_io
-    error = assert_raise(TypeError) do
-      XML::HTMLParser.io(nil)
+    error = assert_raises(TypeError) do
+      LibXML::XML::HTMLParser.io(nil)
     end
 
     assert_equal("Must pass in an IO object", error.to_s)
@@ -166,13 +165,13 @@ class TestSaxParser < Test::Unit::TestCase
 
   def test_string_no_callbacks
     xml = File.read(saxtest_file)
-    parser = XML::SaxParser.string(xml)
+    parser = LibXML::XML::SaxParser.string(xml)
     assert_equal true, parser.parse
   end
 
   def test_string
     xml = File.read(saxtest_file)
-    parser = XML::SaxParser.string(xml)
+    parser = LibXML::XML::SaxParser.string(xml)
     parser.callbacks = TestCaseCallbacks.new
     parser.parse
     verify(parser)
@@ -181,16 +180,16 @@ class TestSaxParser < Test::Unit::TestCase
   def test_string_io
     xml = File.read(saxtest_file)
     io = StringIO.new(xml)
-    parser = XML::SaxParser.io(io)
-    
+    parser = LibXML::XML::SaxParser.io(io)
+
     parser.callbacks = TestCaseCallbacks.new
     parser.parse
     verify(parser)
   end
 
   def test_nil_string
-    error = assert_raise(TypeError) do
-      XML::SaxParser.string(nil)
+    error = assert_raises(TypeError) do
+      LibXML::XML::SaxParser.string(nil)
     end
 
     assert_equal("wrong argument type nil (expected String)", error.to_s)
@@ -204,10 +203,10 @@ class TestSaxParser < Test::Unit::TestCase
 <a>a1</a>
 </Results>
 EOS
-    parser = XML::SaxParser.string(xml)
+    parser = LibXML::XML::SaxParser.string(xml)
     parser.callbacks = DocTypeCallback.new
     doc = parser.parse
-    assert_not_nil(doc)
+    refute_nil(doc)
   end
 
   def test_parse_warning
@@ -218,7 +217,7 @@ EOS
 <Test/>
 EOS
 
-    parser = XML::SaxParser.string(xml)
+    parser = LibXML::XML::SaxParser.string(xml)
     parser.callbacks = TestCaseCallbacks.new
 
     parser.parse
@@ -240,36 +239,43 @@ EOS
     xml = <<-EOS
       <Results>
     EOS
-    parser = XML::SaxParser.string(xml)
+    parser = LibXML::XML::SaxParser.string(xml)
     parser.callbacks = TestCaseCallbacks.new
 
-    error = assert_raise(XML::Error) do
-      doc = parser.parse
+    error = assert_raises(LibXML::XML::Error) do
+      parser.parse
     end
 
     # Check callbacks
     result = parser.callbacks.result
 
     i = -1
+
+    base_err_msg = "Fatal error: (Premature end of data in tag Results line 1|EndTag: '<\\/' not found) at :2\\."
+    re_err_msg1 = /\A(error: )#{base_err_msg}\z/
+    re_err_msg2 = /\A#{base_err_msg}\z/
+
     assert_equal("startdoc", result[i+=1])
     assert_equal("start_element: Results, attr: {}", result[i+=1])
     assert_equal("start_element_ns: Results, attr: {}, prefix: , uri: , ns: {}", result[i+=1])
     assert_equal("characters: \n", result[i+=1])
-    assert_equal("error: Fatal error: Premature end of data in tag Results line 1 at :2.", result[i+=1])
+    assert_match(re_err_msg1, result[i+=1])
     assert_equal("end_document", result[i+=1])
 
-    assert_not_nil(error)
-    assert_kind_of(XML::Error, error)
-    assert_equal("Fatal error: Premature end of data in tag Results line 1 at :2.", error.message)
-    assert_equal(XML::Error::PARSER, error.domain)
-    assert_equal(XML::Error::TAG_NOT_FINISHED, error.code)
-    assert_equal(XML::Error::FATAL, error.level)
+    refute_nil(error)
+    assert_kind_of(LibXML::XML::Error, error)
+    assert_match(re_err_msg2, error.message)
+    assert_equal(LibXML::XML::Error::PARSER, error.domain)
+
+    assert([LibXML::XML::Error::TAG_NOT_FINISHED, LibXML::XML::Error::LTSLASH_REQUIRED].include?(error.code))
+    assert_equal(LibXML::XML::Error::FATAL, error.level)
     assert_nil(error.file)
     assert_equal(2, error.line)
-    assert_equal('Results', error.str1)
+    # Sometimes this is nil and sometimes its not depending on OS and libxlm version
+    # assert_nil(error.str1)
     assert_nil(error.str2)
     assert_nil(error.str3)
-    assert_equal(1, error.int1)
+    assert([0, 1].include?(error.int1))
     assert_equal(1, error.int2)
     assert_nil(error.node)
   end
@@ -306,15 +312,15 @@ EOS
       </Products>
     EOS
 
-    parser = XML::SaxParser.string(xml)
+    parser = LibXML::XML::SaxParser.string(xml)
     parser.callbacks = TestCaseCallbacks.new
 
-    error = assert_raise(XML::Error) do
+    error = assert_raises(LibXML::XML::Error) do
       parser.parse
     end
     assert_equal("Fatal error: xmlParseEntityRef: no name at :5.", error.to_s)
 
     # Check callbacks
-    result = parser.callbacks.result
+    parser.callbacks.result
   end
 end