smile-xml 1.0.0-jruby → 1.0.2-jruby

data/src/test/ruby/tc_reader.rb

@@ -0,0 +1,306 @@
+# 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.to_s
+    reader.read
+
+    # Read a node
+    node = reader.expand
+    assert_equal('feed', node.name)
+    assert_equal(::Encoding::UTF_8, node.name.encoding) if defined?(::Encoding)
+
+    # Try to access the document
+    error = assert_raise(XML::Error) do
+      assert_not_nil(node.doc)
+    end
+    assert_equal(" Document is not accessible to Ruby (hint - did you call Reader#expand?).", error.to_s)
+  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/src/test/ruby/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/src/test/ruby/tc_sax_parser.rb

@@ -0,0 +1,340 @@
+# 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])
+    puts "TODO #{__FILE__} #{__LINE__}"
+    #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])
+    puts "TODO #{__FILE__} #{__LINE__}"
+    #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])
+    puts "TODO #{__FILE__} #{__LINE__}"
+    #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])
+    puts "TODO #{__FILE__} #{__LINE__}"
+    #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])
+    puts "TODO #{__FILE__} #{__LINE__}"
+    #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])
+    puts "TODO #{__FILE__} #{__LINE__}"
+    #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])
+    puts "TODO #{__FILE__} #{__LINE__}"
+    #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])
+    puts "TODO #{__FILE__} #{__LINE__}"
+    #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])
+    puts "TODO #{__FILE__} #{__LINE__}"
+    #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])
+    puts "TODO #{__FILE__} #{__LINE__}"
+    #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])
+    puts "TODO #{__FILE__} #{__LINE__}"
+    #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])
+    puts "TODO #{__FILE__} #{__LINE__}"
+    #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_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])
+    puts "TODO #{__FILE__} #{__LINE__}"
+    #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])
+    puts "TODO #{__FILE__} #{__LINE__}"
+    #assert_equal("start_element_ns: Test, attr: {}, prefix: , uri: , ns: {}", result[i+=1])
+    assert_equal("end_element: Test", result[i+=1])
+    puts "TODO #{__FILE__} #{__LINE__}"
+    #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])
+    puts "TODO #{__FILE__} #{__LINE__}"
+    #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
+#
+  def test_parse_seg_fail
+    xml = <<-EOS
+      <?xml version="1.0" encoding="ISO-8859-1" ?>
+      <Products>
+        <Product>
+          <ProductDescription>
+            AQUALIA THERMAL Lichte cr├иme - Versterkende & kalmerende 24 u hydraterende verzorging<br />
+            Huid wordt continu gehydrateerd, intens versterkt en gekalmeerd.<br />
+            Hypoallergeen. Geschikt voor de gevoelige huid.<br />
+            <br />
+            01.EFFECTIVITEIT<br />
+            Intensief gehydrateerd, de huid voelt gekalmeerd. Ze voelt de hele dag soepel en fluweelzacht aan, zonder een trekkerig gevoel. De huid is elastischer, soepeler en stralender. Doeltreffendheid getest onder dermatologisch toezicht. <br />
+            <br />
+            02.GEBRUIK<br />
+            's Morgens en/ of 's avonds aanbrengen. <br />
+            <br />
+            03.ACTIEVE INGREDIENTEN<br />
+            Technologische innovatie: 24 u continue cellulaire vochtnevel. Voor de 1ste keer worden Thermaal Bronwater van Vichy, rijk aan zeldzame mineralen en Actief HyaluronineтДв verwerkt in microcapsules, die deze vervolgens verspreiden in de cellen. <br />
+            <br />
+            04.TEXTUUR<br />
+            De lichte cr├иme is verfrissend en trekt makkelijk in. Niet vet en niet kleverig. Zonder 'maskereffect'. <br />
+            <br />
+            05.GEUR<br />
+            Geparfumeerd <br />
+            <br />
+            06.INHOUD<br />
+            40 ml tube <br />
+          </ProductDescription>
+        </Product>
+      </Products>
+    EOS
+
+    parser = XML::SaxParser.string(xml)
+    parser.callbacks = TestCaseCallbacks.new
+
+    error = assert_raise(XML::Error) do
+      parser.parse
+    end
+    puts "TODO #{__FILE__} #{__LINE__}"
+    #assert_equal("Fatal error: xmlParseEntityRef: no name at :5.", error.to_s)
+
+    # Check callbacks
+    result = parser.callbacks.result
+  end
+  
+   
+  def test_nil_io
+    puts "TODO #{__FILE__} #{__LINE__}"
+#    error = assert_raise(TypeError) do
+#      XML::HTMLParser.io(nil)
+#    end
+#
+#    assert_equal("Must pass in an IO object", error.to_s)
+  end
+
+end