libxml-ruby 2.0.0-x86-mingw32

data/test/tc_properties.rb

@@ -0,0 +1,39 @@
+# encoding: UTF-8
+
+require './test_helper'
+
+require 'test/unit'
+
+# attributes is deprecated - use attributes instead.
+# Tests for backwards compatibility
+
+class Testattributes < Test::Unit::TestCase
+  def setup()
+    xp = XML::Parser.string('<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>')
+    @doc = xp.parse
+  end
+
+  def teardown()
+    @doc = nil
+  end
+
+  def test_traversal
+    attributes = @doc.root.attributes
+    
+    assert_instance_of(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_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_equal(0, attributes.length)
+  end
+end

data/test/tc_reader.rb

@@ -0,0 +1,298 @@
+# encoding: UTF-8
+
+require './test_helper'
+require 'stringio'
+require 'test/unit'
+
+class TestReader < Test::Unit::TestCase
+  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 = [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]
+
+    assert_equal(expected, node_types)
+  end
+
+  def test_document
+    reader = XML::Reader.document(XML::Document.file(XML_FILE))
+    verify_simple(reader)
+  end
+
+  def test_file
+    reader = XML::Reader.file(XML_FILE)
+    verify_simple(reader)
+  end
+
+  def test_invalid_file
+    assert_raise(XML::Error) do
+      XML::Reader.file('/does/not/exist')
+    end
+  end
+
+  def test_string
+    reader = 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)
+      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 = 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 = XML::Reader.io(string_io)
+    verify_simple(reader)
+  end
+
+  def test_error
+    reader = XML::Reader.string('<foo blah')
+
+    error = assert_raise(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_deprecated_error_handler
+    called = false
+    reader = XML::Reader.string('<foo blah')
+    reader.set_error_handler do |error|
+      called = true
+    end
+
+    assert_raise(XML::Error) do
+      reader.read
+    end
+
+    assert(called)
+  end
+
+  def test_deprecated_reset_error_handler
+    called = false
+    reader = XML::Reader.string('<foo blah')
+    reader.set_error_handler do |error|
+      called = true
+    end
+    reader.reset_error_handler
+
+    assert_raise(XML::Error) do
+      reader.read
+    end
+
+    assert(!called)
+  end
+
+  def test_attr
+    parser = 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_equal(nil, parser['z'])
+    assert_equal(nil, parser[2])
+  end
+
+  def test_value
+    parser = XML::Reader.string("<foo><bar>1</bar><bar>2</bar><bar>3</bar></foo>")
+    assert(parser.read)
+    assert_equal('foo', parser.name)
+    assert_equal(nil, parser.value)
+    3.times do |i|
+      assert(parser.read)
+      assert_equal(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((i + 1).to_s, parser.value)
+      assert(parser.read)
+      assert_equal(XML::Reader::TYPE_END_ELEMENT, parser.node_type)
+    end
+  end
+
+  def test_expand
+    reader = XML::Reader.file(XML_FILE)
+    reader.read
+    node = reader.expand
+    assert_nil(node.doc)
+    reader.close
+    GC.start
+  end
+
+  def test_mode
+    reader = XML::Reader.string('<xml/>')
+    assert_equal(XML::Reader::MODE_INITIAL, reader.read_state)
+    reader.read
+    assert_equal(XML::Reader::MODE_EOF, reader.read_state)
+  end
+
+  def test_bytes_consumed
+    reader = XML::Reader.file(XML_FILE)
+    reader.read
+    assert_equal(416, reader.byte_consumed)
+  end
+
+  def test_node
+    XML.default_line_numbers = true
+    reader = XML::Reader.file(XML_FILE)
+
+    # first try to get a node
+    assert_nil(reader.node)
+
+    reader.read
+    assert_instance_of(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 = 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 = 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)
+
+    # Convert cdata section to text
+    reader = XML::Reader.string(xml, :options => 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)
+  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 = XML::Reader.string(xml, :encoding => 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
+  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 = XML::Reader.string(xml)
+    error = assert_raise(XML::Error) do
+      node = 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 = 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)
+  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 = XML::Reader.string(xml, :encoding => XML::Encoding::ISO_8859_1)
+    reader.read
+
+    # Encoding is always null for strings, very annoying!
+    assert_equal(reader.encoding, XML::Encoding::NONE)
+  end
+end

data/test/tc_relaxng.rb

@@ -0,0 +1,54 @@
+# encoding: UTF-8
+
+require './test_helper'
+
+require 'test/unit'
+
+class TestRelaxNG < Test::Unit::TestCase
+  def setup
+    file = File.join(File.dirname(__FILE__), 'model/shiporder.xml')
+    @doc = XML::Document.file(file)
+  end
+  
+  def teardown
+    @doc = nil
+  end
+  
+  def relaxng
+    document = XML::Document.file(File.join(File.dirname(__FILE__), 'model/shiporder.rng'))
+    relaxng = XML::RelaxNG.document(document)
+  end
+
+  def test_from_doc
+    assert_instance_of(XML::RelaxNG, relaxng)
+  end
+  
+  def test_valid
+    assert(@doc.validate_relaxng(relaxng))
+  end
+  
+  def test_invalid
+    new_node = XML::Node.new('invalid', 'this will mess up validation')
+    @doc.root << new_node
+    
+    error = assert_raise(XML::Error) do
+      @doc.validate_relaxng(relaxng)
+    end
+
+    assert_not_nil(error)
+    assert_kind_of(XML::Error, error)
+    assert(error.message.match(/Error: Did not expect element invalid there/))
+    assert_equal(XML::Error::RELAXNGV, error.domain)
+    assert_equal(XML::Error::LT_IN_ATTRIBUTE, error.code)
+    assert_equal(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)
+    assert_not_nil(error.node)
+    assert_equal('invalid', error.node.name)
+  end
+end

data/test/tc_sax_parser.rb

@@ -0,0 +1,276 @@
+# encoding: UTF-8
+
+require './test_helper'
+require 'stringio'
+require 'test/unit'
+
+class DocTypeCallback
+  include XML::SaxParser::Callbacks
+  def on_start_element(element, attributes)
+  end
+end
+
+class TestCaseCallbacks
+  include XML::SaxParser::Callbacks
+
+  attr_accessor :result
+
+  def initialize
+    @result = Array.new
+  end
+
+  def on_cdata_block(cdata)
+    @result << "cdata: #{cdata}"
+  end
+
+  def on_characters(chars)
+    @result << "characters: #{chars}"
+  end
+
+  def on_comment(text)
+    @result << "comment: #{text}"
+  end
+
+  def on_end_document
+    @result << "end_document"
+  end
+
+  def on_end_element(name)
+    @result << "end_element: #{name}"
+  end
+
+  def on_end_element_ns(name, prefix, uri)
+    @result << "end_element_ns #{name}, prefix: #{prefix}, uri: #{uri}"
+  end
+
+  # Called for parser errors.
+  def on_error(error)
+    @result << "error: #{error}"
+  end
+
+  def on_processing_instruction(target, data)
+    @result << "pi: #{target} #{data}"
+  end
+
+  def on_start_document
+    @result << "startdoc"
+  end
+
+  def on_start_element(name, attributes)
+    attributes ||= Hash.new
+    @result << "start_element: #{name}, attr: #{attributes.inspect}"
+  end
+
+  def on_start_element_ns(name, attributes, prefix, uri, namespaces)
+    attributes ||= Hash.new
+    namespaces ||= Hash.new
+    @result << "start_element_ns: #{name}, attr: #{attributes.inspect}, prefix: #{prefix}, uri: #{uri}, ns: #{namespaces.inspect}"
+  end
+end
+
+class TestSaxParser < Test::Unit::TestCase
+  def saxtest_file
+    File.join(File.dirname(__FILE__), 'model/atom.xml')
+  end
+
+  def verify(parser)
+    result = parser.callbacks.result
+
+    i = -1
+    assert_equal("startdoc", result[i+=1])
+    assert_equal("pi: xml-stylesheet type=\"text/xsl\" href=\"my_stylesheet.xsl\"", result[i+=1])
+    assert_equal("start_element: feed, attr: {}", result[i+=1])
+    assert_equal("start_element_ns: feed, attr: {}, prefix: , uri: http://www.w3.org/2005/Atom, ns: {nil=>\"http://www.w3.org/2005/Atom\"}", result[i+=1])
+    assert_equal("characters: \n  ", result[i+=1])
+    assert_equal("comment:  Not a valid atom entry ", result[i+=1])
+    assert_equal("characters: \n  ", result[i+=1])
+    assert_equal("start_element: entry, attr: {}", result[i+=1])
+    assert_equal("start_element_ns: entry, attr: {}, prefix: , uri: http://www.w3.org/2005/Atom, ns: {}", result[i+=1])
+    assert_equal("characters: \n    ", result[i+=1])
+    assert_equal("start_element: title, attr: {\"type\"=>\"html\"}", result[i+=1])
+    assert_equal("start_element_ns: title, attr: {\"type\"=>\"html\"}, prefix: , uri: http://www.w3.org/2005/Atom, ns: {}", result[i+=1])
+    assert_equal("cdata: <<strong>>", result[i+=1])
+    assert_equal("end_element: title", result[i+=1])
+    assert_equal("end_element_ns title, prefix: , uri: http://www.w3.org/2005/Atom", result[i+=1])
+    assert_equal("characters: \n    ", result[i+=1])
+    assert_equal("start_element: content, attr: {\"type\"=>\"xhtml\"}", result[i+=1])
+    assert_equal("start_element_ns: content, attr: {\"type\"=>\"xhtml\"}, prefix: , uri: http://www.w3.org/2005/Atom, ns: {}", result[i+=1])
+    assert_equal("characters: \n      ", result[i+=1])
+    assert_equal("start_element: xhtml:div, attr: {}", result[i+=1])
+    assert_equal("start_element_ns: div, attr: {}, prefix: xhtml, uri: http://www.w3.org/1999/xhtml, ns: {\"xhtml\"=>\"http://www.w3.org/1999/xhtml\"}", result[i+=1])
+    assert_equal("characters: \n        ", result[i+=1])
+    assert_equal("start_element: xhtml:p, attr: {}", result[i+=1])
+    assert_equal("start_element_ns: p, attr: {}, prefix: xhtml, uri: http://www.w3.org/1999/xhtml, ns: {}", result[i+=1])
+    assert_equal("characters: hi there", result[i+=1])
+    assert_equal("end_element: xhtml:p", result[i+=1])
+    assert_equal("end_element_ns p, prefix: xhtml, uri: http://www.w3.org/1999/xhtml", result[i+=1])
+    assert_equal("characters: \n      ", result[i+=1])
+    assert_equal("end_element: xhtml:div", result[i+=1])
+    assert_equal("end_element_ns div, prefix: xhtml, uri: http://www.w3.org/1999/xhtml", result[i+=1])
+    assert_equal("characters: \n    ", result[i+=1])
+    assert_equal("end_element: content", result[i+=1])
+    assert_equal("end_element_ns content, prefix: , uri: http://www.w3.org/2005/Atom", result[i+=1])
+    assert_equal("characters: \n  ", result[i+=1])
+    assert_equal("end_element: entry", result[i+=1])
+    assert_equal("end_element_ns entry, prefix: , uri: http://www.w3.org/2005/Atom", result[i+=1])
+    assert_equal("characters: \n", result[i+=1])
+    assert_equal("end_element: feed", result[i+=1])
+    assert_equal("end_element_ns feed, prefix: , uri: http://www.w3.org/2005/Atom", result[i+=1])
+    assert_equal("end_document", result[i+=1])
+  end
+
+  def test_file
+    parser = 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)
+    assert_equal true, parser.parse
+  end
+
+  def test_noexistent_file
+    error = assert_raise(XML::Error) do
+      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)
+    end
+
+    assert_equal("can't convert nil into String", error.to_s)
+  end
+
+  def test_io
+    File.open(saxtest_file) do |file|
+      parser = XML::SaxParser.io(file)
+      parser.callbacks = TestCaseCallbacks.new
+      parser.parse
+      verify(parser)
+    end
+  end
+
+  def test_nil_io
+    error = assert_raise(TypeError) do
+      XML::HTMLParser.io(nil)
+    end
+
+    assert_equal("Must pass in an IO object", error.to_s)
+  end
+
+  def test_string_no_callbacks
+    xml = File.read(saxtest_file)
+    parser = XML::SaxParser.string(xml)
+    assert_equal true, parser.parse
+  end
+
+  def test_string
+    xml = File.read(saxtest_file)
+    parser = XML::SaxParser.string(xml)
+    parser.callbacks = TestCaseCallbacks.new
+    parser.parse
+    verify(parser)
+  end
+
+  def test_string_io
+    xml = File.read(saxtest_file)
+    io = StringIO.new(xml)
+    parser = 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)
+    end
+
+    assert_equal("wrong argument type nil (expected String)", error.to_s)
+  end
+
+  def test_doctype
+    xml = <<-EOS
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE Results SYSTEM "results.dtd">
+<Results>
+  <a>a1</a>
+</Results>
+EOS
+    parser = XML::SaxParser.string(xml)
+    parser.callbacks = DocTypeCallback.new
+    doc = parser.parse
+    assert_not_nil(doc)
+  end
+
+  def test_parse_warning
+    # Two xml PIs is a warning
+    xml = <<-EOS
+<?xml version="1.0" encoding="utf-8"?>
+<?xml-invalid?>
+<Test/>
+EOS
+
+    parser = XML::SaxParser.string(xml)
+    parser.callbacks = TestCaseCallbacks.new
+
+    parser.parse
+
+    # Check callbacks
+    result = parser.callbacks.result
+    i = -1
+    assert_equal("startdoc", result[i+=1])
+    assert_equal("error: Warning: xmlParsePITarget: invalid name prefix 'xml' at :2.", result[i+=1])
+    assert_equal("pi: xml-invalid ", result[i+=1])
+    assert_equal("start_element: Test, attr: {}", result[i+=1])
+    assert_equal("start_element_ns: Test, attr: {}, prefix: , uri: , ns: {}", result[i+=1])
+    assert_equal("end_element: Test", result[i+=1])
+    assert_equal("end_element_ns Test, prefix: , uri: ", result[i+=1])
+    assert_equal("end_document", result[i+=1])
+  end
+
+  def test_parse_error
+    xml = <<-EOS
+      <Results>
+    EOS
+    parser = XML::SaxParser.string(xml)
+    parser.callbacks = TestCaseCallbacks.new
+
+    error = assert_raise(XML::Error) do
+      doc = parser.parse
+    end
+
+    # Check callbacks
+    result = parser.callbacks.result
+
+    i = -1
+    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_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)
+    assert_nil(error.file)
+    assert_equal(2, error.line)
+    assert_equal('Results', error.str1)
+    assert_nil(error.str2)
+    assert_nil(error.str3)
+    assert_equal(1, error.int1)
+    assert_equal(1, error.int2)
+    assert_nil(error.node)
+  end
+end