libxml-ruby 0.8.3-x86-mswin32-60 → 0.9.0-x86-mswin32-60

data/test/tc_document_write.rb

@@ -1,7 +1,7 @@
 require "xml"
 require 'test/unit'
 
-class TC_XML_Document_Write < Test::Unit::TestCase
+class TestDocumentWrite < Test::Unit::TestCase
   def setup
     @doc = XML::Document.new('1.0')
   end
@@ -35,13 +35,6 @@ class TC_XML_Document_Write < Test::Unit::TestCase
     assert_equal("<?xml version=\"1.0\"?>\n<rubynet/>\n", @doc.to_s(false))
   end
 
-  def test_encoding
-    @doc.root = XML::Node.new('rubynet')
-    @doc.encoding = 'UTF-8'
-    assert_instance_of(XML::Node, @doc.root)
-    assert_equal("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<rubynet/>\n", @doc.to_s)
-  end
-
   def test_child()
     xml = "<?xml version=\"1.0\"?>\n<rubynet>\n  <pkg/>\n</rubynet>\n"
     @doc.root = XML::Node.new('rubynet')
@@ -136,4 +129,18 @@ class TC_XML_Document_Write < Test::Unit::TestCase
     pkgname = meta.child = XML::Node.new('pkgname', 'libxml')
     assert_equal(xml, @doc.to_s)
   end
+
+  def test_encoding_utf
+    @doc.root = XML::Node.new('rubynet')
+    @doc.encoding = XML::Encoding.encoding_to_s(XML::Encoding::UTF8)
+    assert_instance_of(XML::Node, @doc.root)
+    assert_equal("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<rubynet/>\n", @doc.to_s)
+  end
+
+  def test_encoding_latin1
+    @doc.root = XML::Node.new('rubynet')
+    @doc.encoding = XML::Encoding.encoding_to_s(XML::Encoding::ISO_8859_1)
+    assert_instance_of(XML::Node, @doc.root)
+    assert_equal("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n<rubynet/>\n", @doc.to_s)
+  end
 end

data/test/tc_dtd.rb

@@ -31,20 +31,32 @@ class TestDtd < Test::Unit::TestCase
   def test_valid
     assert(@doc.validate(dtd))
   end
-  
+
   def test_invalid
     new_node = XML::Node.new('invalid', 'this will mess up validation')
     @doc.root.child_add(new_node)
-    
+
     messages = Hash.new
-    assert(!@doc.validate(dtd) do |message, error|
-      messages[message] = error
-    end)
+    error = assert_raise(XML::Error) do
+      @doc.validate(dtd)
+    end
 
-    expected = {"No declaration for element invalid\n" => true,
-                "Element root content does not follow the DTD, expecting (head , descr), got (head descr invalid)\n" => true}
-      
-    assert_equal(expected, messages)
+    # Check the error worked
+    assert_not_nil(error)
+    assert_kind_of(XML::Error, error)
+    assert_equal("Error: No declaration for element invalid at :0.", error.message)
+    assert_equal(XML::Error::VALID, error.domain)
+    assert_equal(XML::Error::DTD_UNKNOWN_ELEM, error.code)
+    assert_equal(XML::Error::ERROR, error.level)
+    assert_nil(error.file)
+    assert_nil(error.line)
+    assert_equal('invalid', error.str1)
+    assert_equal('invalid', 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
   
   def test_external_dtd
@@ -54,17 +66,21 @@ class TestDtd < Test::Unit::TestCase
         <title>T1</title>
       </test>
     EOS
-    
-    messages = Array.new
-    XML::Parser.register_error_handler(lambda { |msg| messages << msg })
-    
-    XML::Parser.default_load_external_dtd = false
+
+    errors = Array.new
+    XML::Error.set_handler do |error|
+      errors << error
+    end
+
+    XML.default_load_external_dtd = false
     doc = XML::Parser.string(xml).parse
-    assert_equal(Array.new, messages)
-    
-    XML::Parser.default_load_external_dtd = true
+    assert_equal(Array.new, errors)
+
+    XML.default_load_external_dtd = true
     doc = XML::Parser.string(xml).parse
-    assert_equal('I/O warning : failed to load external entity "test.dtd" <!DOCTYPE test PUBLIC "-//TEST" "test.dtd" []> ^',
-                 messages.map{|msg| msg.strip}.join(' ')) 
+    assert_equal("Warning: failed to load external entity \"test.dtd\" at :1.",
+                  errors.map do |error|
+                    error.to_s
+                  end.join(' '))
   end
-end
+end

data/test/tc_encoding.rb

@@ -0,0 +1,13 @@
+require 'xml'
+require 'test/unit'
+
+class TestEncoding < Test::Unit::TestCase
+  def test_latin1
+    assert_equal(XML::Encoding::ISO_8859_1, 10)
+  end
+
+  def test_latin1_to_s
+    encoding_str = XML::Encoding.encoding_to_s(XML::Encoding::ISO_8859_1)
+    assert_equal('ISO-8859-1', encoding_str)
+  end
+end

data/test/tc_error.rb

@@ -0,0 +1,136 @@
+require 'xml'
+require 'test/unit'
+require 'stringio'
+
+class TestError < Test::Unit::TestCase
+  def test_invalid_handler
+    assert_raises(RuntimeError) do
+      XML::Error.set_handler
+    end
+  end
+
+  def test_handler
+    exception = nil
+    XML::Error.set_handler do |error|
+      exception = error
+    end
+
+    # Raise the error
+    XML::Reader.new('<foo').read
+
+    # Check the handler worked
+    assert_not_nil(exception)
+    assert_kind_of(XML::Error, exception)
+    assert_equal("Fatal error: Couldn't find end of Start Tag foo at :1.", exception.message)
+    assert_equal(XML::Error::XML_FROM_PARSER, exception.domain)
+    assert_equal(XML::Error::XML_ERR_GT_REQUIRED, exception.code)
+    assert_equal(XML::Error::XML_ERR_FATAL, exception.level)
+    assert_nil(exception.file)
+    assert_equal(1, exception.line)
+    assert_equal('foo', exception.str1)
+    assert_nil(exception.str2)
+    assert_nil(exception.str3)
+    assert_equal(0, exception.int1)
+    assert_equal(5, exception.int2)
+    assert_nil(exception.node)
+  end
+
+  def test_reset_handler
+    exception = nil
+    XML::Error.set_handler do |error|
+      exception = error
+    end
+
+    XML::Error.reset_handler
+    reader = XML::Reader.new('<foo')
+    assert_nil(exception)
+  end
+
+  def test_verbose_handler
+    XML::Error.set_handler(&XML::Error::VERBOSE_HANDLER)
+    output = StringIO.new
+    original_stderr = Object::STDERR
+
+    Object.const_set(:STDERR, output)
+    begin
+      assert_raise(XML::Error) do
+        XML::Parser.string('<foo><bar/></foz>').parse
+      end
+    ensure
+      Object.const_set(:STDERR, original_stderr)
+    end
+    assert_equal("Fatal error: Opening and ending tag mismatch: foo line 1 and foz at :1.\n", output.string)
+  end
+
+  def test_no_hanlder
+    XML::Error.reset_handler
+    output = StringIO.new
+    original_stderr = Object::STDERR
+
+    Object.const_set(:STDERR, output)
+    begin
+      assert_raise(XML::Error) do
+        XML::Parser.string('<foo><bar/></foz>').parse
+      end
+    ensure
+      Object.const_set(:STDERR, original_stderr)
+    end
+    assert_equal('', output.string)
+  end
+
+  def test_parse_error
+    exception = assert_raise(XML::Error) do
+      XML::Parser.string('<foo><bar/></foz>').parse
+    end
+
+    assert_instance_of(XML::Error, exception)
+    assert_equal("Fatal error: Opening and ending tag mismatch: foo line 1 and foz at :1.", exception.message)
+    assert_equal(XML::Error::XML_FROM_PARSER, exception.domain)
+    assert_equal(XML::Error::XML_ERR_TAG_NAME_MISMATCH, exception.code)
+    assert_equal(XML::Error::XML_ERR_FATAL, exception.level)
+    assert_nil(exception.file)
+    assert_equal(1, exception.line)
+  end
+
+  def test_xpath_error
+    doc = XML::Document.file(File.join(File.dirname(__FILE__), 'model/soap.xml'))
+
+    exception = assert_raise(XML::Error) do
+      elements = doc.find('/foo[bar=test')
+    end
+
+    assert_instance_of(XML::Error, exception)
+    assert_equal("Error: Invalid predicate at :0.", exception.message)
+    assert_equal(XML::Error::XML_FROM_XPATH, exception.domain)
+    assert_equal(XML::Error::XML_XPATH_INVALID_PREDICATE_ERROR, exception.code)
+    assert_equal(XML::Error::XML_ERR_ERROR, exception.level)
+    assert_nil(exception.file)
+    assert_nil(nil)
+  end
+
+  def test_double_parse
+    XML::Parser.register_error_handler(lambda {|msg| nil })
+    parser = XML::Parser.string("<test>something</test>")
+    doc = parser.parse
+
+    error = assert_raise(RuntimeError) do
+      # Try parsing a second time
+      parser.parse
+    end
+
+    assert_equal("You cannot parse a data source twice", error.to_s)
+  end
+
+  def test_libxml_parser_empty_string
+    xp = XML::Parser.new
+
+    assert_raise(TypeError) do
+      xp.string = nil
+    end
+
+    xp.string = ''
+    assert_raise(XML::Error) do
+      xp.parse
+    end
+  end
+end

data/test/tc_node.rb

@@ -54,9 +54,8 @@ class TestNode < Test::Unit::TestCase
   end
 
   def test_node_find
-    set = @doc.root.find('./fixnum').set
-    assert_instance_of(XML::Node::Set, set)
-    for node in set
+    nodes = @doc.root.find('./fixnum')
+    for node in nodes
       assert_instance_of(XML::Node, node)
     end
   end

data/test/tc_node_copy.rb

@@ -1,4 +1,4 @@
-require "xml"
+require 'xml'
 require 'test/unit'
 
 # see mailing list archive

data/test/tc_node_edit.rb

@@ -88,4 +88,10 @@ class TestNodeEdit < Test::Unit::TestCase
       master_doc
     end
   end
+  
+  def test_append_chain
+    node = XML::Node.new('foo') << XML::Node.new('bar') << "bars contents"
+    assert_equal('<foo><bar/>bars contents</foo>',
+                 node.to_s)
+  end
 end

data/test/tc_ns.rb

@@ -0,0 +1,18 @@
+require "xml"
+require 'test/unit'
+
+class TestNS < Test::Unit::TestCase
+  def test_ns
+    node = XML::Node.new('foo')
+    ns = XML::NS.new(node, 'http://www.mynamespace.com', 'my_namepace')
+    assert_equal(ns.prefix, 'my_namepace')
+    assert_equal(ns.href, 'http://www.mynamespace.com')
+  end
+  
+  def test_default_ns
+    node = XML::Node.new('foo')
+    ns = XML::NS.new(node, 'http://www.mynamespace.com', nil)
+    assert_equal(ns.prefix, nil)
+    assert_equal(ns.href, 'http://www.mynamespace.com')
+  end
+end

data/test/tc_parser.rb

@@ -1,294 +1,179 @@
-require "xml"
+require 'xml'
 require 'test/unit'
+require 'stringio'
 
 class TestParser < Test::Unit::TestCase
   def setup
-    XML::Parser.register_error_handler(nil)
+    XML::Error.set_handler(&XML::Error::QUIET_HANDLER)
     @xp = XML::Parser.new
   end
 
   def teardown
     @xp = nil
-    XML::Parser.register_error_handler(nil)
-    # Clear out all the files we opened up in
-    # the test_fd_gc test
+    GC.start
+    GC.start
     GC.start
   end
       
-  # -----  Constants  ------
-  def test_lib_versions
-    assert(XML::Parser::check_lib_versions)
-  end
-
-  def test_debug_entities
-    XML::Parser::debug_entities = false
-    assert(!XML::Parser::debug_entities)
-
-    XML::Parser::debug_entities = true
-    assert(XML::Parser::debug_entities)
-
-    XML::Parser::debug_entities = false
-    assert(!XML::Parser::debug_entities)
-  end
-
-  def test_default_compression
-    return unless XML::Parser::default_compression
-    
-    0.upto(9) do |i|
-      XML::Parser::default_compression = i
-      assert_equal(i, XML::Parser::default_compression)
-    end
-
-    9.downto(0) do |i|
-      assert_equal(i, XML::Parser::default_compression = i)
-      assert_equal(i, XML::Parser::default_compression)
-    end
-
-    0.downto(-10) do |i|
-      assert_equal(i, XML::Parser::default_compression = i)
-      assert_equal(0, XML::Parser::default_compression)
-    end
-
-    10.upto(20) do |i|
-      assert_equal(i, XML::Parser::default_compression = i)
-      assert_equal(9, XML::Parser::default_compression)
-    end
-  end
-
-  def test_default_keep_blanks
-    XML::Parser::default_keep_blanks = false
-    assert(!XML::Parser::default_keep_blanks)
-
-    XML::Parser::default_keep_blanks = true
-    assert(XML::Parser::default_keep_blanks)
-
-    XML::Parser::default_keep_blanks = false
-    assert(!XML::Parser::default_keep_blanks)
-
-    # other tests depend on keeping blanks by default,
-    # which is the default default behaviour anyway.
-    XML::Parser::default_keep_blanks = true
-  end
-
-  def test_default_line_numbers
-    XML::Parser::default_line_numbers = false
-    assert(!XML::Parser::default_line_numbers)
-
-    XML::Parser::default_line_numbers = true
-    assert(XML::Parser::default_line_numbers)
-
-    XML::Parser::default_line_numbers = false
-    assert(!XML::Parser::default_line_numbers)
-  end
+  # -----  Sources  ------
+  def test_file
+    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
 
-  def test_default_substitute_entities
-    XML::Parser::default_substitute_entities = false
-    assert(!XML::Parser::default_substitute_entities)
+    @xp.file = file
+    assert_equal(file, @xp.file)
+    assert_equal(file, @xp.input.file)
 
-    XML::Parser::default_substitute_entities = true
-    assert(XML::Parser::default_substitute_entities)
+    doc = @xp.parse
+    assert_instance_of(XML::Document, doc)
+    assert_instance_of(XML::Parser::Context, @xp.context)
+    GC.start
+    GC.start
+    GC.start
+ end
 
-    XML::Parser::default_substitute_entities = false
-    assert(!XML::Parser::default_substitute_entities)
-  end
+  def test_file_class
+    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
 
-  def test_default_tree_indent_string
-    s = XML::Parser::default_tree_indent_string
-    assert_instance_of(String, s)
-    assert_equal('  ', s)
-    XML::Parser::default_tree_indent_string = 'uga'
-    s = XML::Parser::default_tree_indent_string
-    assert_instance_of(String, s)
-    assert_equal('uga', s)
-    XML::Parser::default_tree_indent_string = '  '
-    s = XML::Parser::default_tree_indent_string
-    assert_instance_of(String, s)
-    assert_equal('  ', s)
+    xp = XML::Parser.file(file)
+    assert_instance_of(XML::Parser, xp)
+    assert_equal(file, xp.file)
+    assert_equal(file, xp.input.file)
   end
 
-  def test_default_validity_checking
-    XML::Parser::default_validity_checking = false
-    assert(!XML::Parser::default_validity_checking)
+  def test_string
+    str = '<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
 
-    XML::Parser::default_validity_checking = true
-    assert(XML::Parser::default_validity_checking)
+    @xp.string = str
+    assert_equal(str, @xp.string)
+    assert_equal(str, @xp.input.string)
 
-    XML::Parser::default_validity_checking = false
-    assert(!XML::Parser::default_validity_checking)
+    doc = @xp.parse
+    assert_instance_of(XML::Document, doc)
+    assert_instance_of(XML::Parser::Context, @xp.context)
   end
 
-  def test_default_warnings
-    XML::Parser::default_warnings = false
-    assert(!XML::Parser::default_warnings)
-
-    XML::Parser::default_warnings = true
-    assert(XML::Parser::default_warnings)
+  def test_string_empty
+    assert_raise(XML::Error) do
+      @xp.string = ''
+      @xp.parse
+    end
 
-    XML::Parser::default_warnings = false
-    assert(!XML::Parser::default_warnings)
+    assert_raise(TypeError) do
+      @xp.string = nil
+    end
   end
 
-  def test_intent_tree_output
-    assert(TrueClass, XML::Parser::indent_tree_output)
-
-    XML::Parser::indent_tree_output = false
-    assert(FalseClass, XML::Parser::indent_tree_output)
+  def test_string_class
+    str = '<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
 
-    XML::Parser::indent_tree_output = true
-    assert(TrueClass, XML::Parser::indent_tree_output)
+    xp = XML::Parser.string(str)
+    assert_instance_of(XML::Parser, xp)
+    assert_equal(str, xp.string)
+    assert_equal(str, xp.input.string)
   end
 
-  def test_version
-    assert_instance_of(String, XML::Parser::VERSION)
-  end
+  def test_io
+    File.open(File.join(File.dirname(__FILE__), 'model/rubynet.xml')) do |io|
+      @xp.io = io
+      assert_equal(io, @xp.io)
+      assert_equal(io, @xp.input.io)
 
-  def test_vernum
-    assert_instance_of(Fixnum, XML::Parser::VERNUM)
+      doc = @xp.parse
+      assert_instance_of(XML::Document, doc)
+      assert_instance_of(XML::Parser::Context, @xp.context)
+    end
   end
 
-  # -----  IO  ------
-  def test_string
-    str = '<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
-    assert_equal(str, @xp.string = str)
-    assert_instance_of(XML::Document, @xp.parse)
-  end
-  
-  def test_context
-    @xp = XML::Parser.string('<rubynet><testing>uga</testing><uga>foo</uga></rubynet>')
-    doc = @xp.parse
-    assert_instance_of(XML::Document, doc)
-    assert_instance_of(XML::Parser::Context, @xp.context)
+  def test_io_class
+    File.open(File.join(File.dirname(__FILE__), 'model/rubynet.xml')) do |io|
+      xp = XML::Parser.io(io)
+      assert_instance_of(XML::Parser, xp)
+      assert_equal(io, xp.io)
+      assert_equal(io, xp.input.io)
+    end
   end
 
-  def test_file
-    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
-    
-    @xp.filename = file
-    assert_equal(file, @xp.filename)
-    
-    doc = @xp.parse
-    assert_instance_of(XML::Document, doc)
+  def test_string_io
+    data = File.read(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
+    string_io = StringIO.new(data)
+    assert_raises(TypeError) do
+      @xp.io = string_io
+    end
   end
 
-  def test_io
-    File.open(File.join(File.dirname(__FILE__), 'model/rubynet.xml')) do |f|
-      assert_kind_of(IO, f)
-      assert_kind_of(IO, @xp.io = f)
-      assert_instance_of(XML::Document, @xp.parse)
-    end # File.open
-  end # def test_libxml_parser_io
-
   def test_fd_gc
     # Test opening # of documents up to the file limit for the OS.
-    # Ideally it should run until libxml emits a warning, 
+    # Ideally it should run until libxml emits a warning,
     # thereby knowing we've done a GC sweep. For the time being,
-    # re-open the same doc `limit descriptors` times. 
-    # If we make it to the end, then we've succeeded, 
+    # 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::Parser.register_error_handler(lambda {|msg| nil })
-    
+    XML::Error.set_handler {|error|}
+
     max_fd = if RUBY_PLATFORM.match(/mswin32/i)
       500
     else
       (`ulimit -n`.chomp.to_i) + 1
     end
-    
-    filename = File.join(File.dirname(__FILE__), 'model/rubynet.xml')
+
+    file = File.join(File.dirname(__FILE__), 'model/rubynet.xml')
     max_fd.times do
-       XML::Document.file(filename)
+       XML::Parser.file(file).parse
     end
+    XML::Error.reset_handler {|error|}
   end
 
-  def test_libxml_parser_features
-    assert_instance_of(Array, XML::Parser::features)
-  end
 
   # -----  Errors  ------
-  def test_error_handler
-    assert_raise(XML::Parser::ParseError) do
+  def test_error
+    error = assert_raise(XML::Error) do
       XML::Parser.string('<foo><bar/></foz>').parse
     end
 
-    ary = []
-    XML::Parser.register_error_handler do |msg|
-      ary << msg
-    end
-
-    # this will use our error handler
-    assert_raise(XML::Parser::ParseError) do
-      XML::Parser.string('<foo><bar/></foz>').parse
-    end
-    
-    assert_equal(["Entity: line 1: ",
-                  "parser ",
-                  "error : ",
-                  "Opening and ending tag mismatch: foo line 1 and foz\n",
-                  "<foo><bar/></foz>\n",
-                  "                 ^\n"], ary)
-
-    assert_instance_of(Proc, XML::Parser.register_error_handler(nil))
-
-    # this will go to stderr again
-    assert_raise(XML::Parser::ParseError) do
-      d = XML::Parser.string('<foo><bar/></foz>').parse
-    end
+    assert_not_nil(error)
+    assert_kind_of(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_nil(error.file)
+    assert_equal(1, error.line)
+    assert_equal('foo', error.str1)
+    assert_equal('foz', error.str2)
+    assert_nil(error.str3)
+    assert_equal(1, error.int1)
+    assert_equal(20, error.int2)
+    assert_nil(error.node)
   end
-  
-  def test_error_handler_lambda
-    XML::Parser.register_error_handler(nil)
-    assert_raise(XML::Parser::ParseError) do
-      XML::Parser.string('<foo><bar/></foz>').parse
-    end
 
-    ary = []
-    assert_nil XML::Parser.register_error_handler(lambda { |msg| ary << msg })
-
-    # this will use our error handler
-    assert_raise(XML::Parser::ParseError) do
-      XML::Parser.string('<foo><bar/></foz>').parse
-    end
-    
-    assert_equal(["Entity: line 1: ",
-                  "parser ",
-                  "error : ",
-                  "Opening and ending tag mismatch: foo line 1 and foz\n",
-                  "<foo><bar/></foz>\n",
-                  "                 ^\n"], ary)
-
-    assert_instance_of(Proc, XML::Parser.register_error_handler(nil))
-
-    # this will go to stderr again
-    assert_raise(XML::Parser::ParseError) do
-      d = XML::Parser.string('<foo><bar/></foz>').parse
-    end
-  end
-  
   def test_bad_xml
     @xp.string = '<ruby_array uga="booga" foo="bar"<fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
-    XML::Parser.register_error_handler(lambda {|msg| nil })
-    assert_raise(XML::Parser::ParseError) do
+    error = assert_raise(XML::Error) do
       assert_not_nil(@xp.parse)
     end
+
+    assert_not_nil(error)
+    assert_kind_of(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_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_nil(error.node)
   end
-  
+
   def test_double_parse
-    XML::Parser.register_error_handler(lambda {|msg| nil })
     parser = XML::Parser.string("<test>something</test>")
     doc = parser.parse
-    
-    assert_raise(XML::Parser::ParseError) do
+
+    assert_raise(RuntimeError) do
       parser.parse
     end
   end
-  
-  def test_libxml_parser_empty_string
-    assert_raise(XML::Parser::ParseError) do
-      @xp.string = ''
-      @xp.parse
-    end
-    
-    assert_raise(TypeError) do
-      @xp.string = nil
-    end
-  end
-end
+end