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

data/test/tc_parser_context.rb

@@ -86,7 +86,7 @@ class TestParserContext < Test::Unit::TestCase
     xp = XML::Parser.new
     xp.string = '<foo><bar/></foz>'
     
-    assert_raise(XML::Parser::ParseError) do
+    assert_raise(XML::Error) do
       xp.parse
     end
     
@@ -107,7 +107,6 @@ class TestParserContext < Test::Unit::TestCase
     assert_equal(0, context.name_depth)
     assert_equal(10, context.name_depth_max)
     assert_equal(17, context.num_chars)
-    assert_equal(0, context.options)
     assert_equal(true, context.replace_entities?)
     assert_equal(1, context.space_depth)
     assert_equal(10, context.space_depth_max)

data/test/tc_reader.rb

@@ -1,7 +1,7 @@
 require 'xml'
 require 'test/unit'
 
-class TC_XML_Reader < Test::Unit::TestCase
+class TextReader < Test::Unit::TestCase
 
   SIMPLE_XML = File.join(File.dirname(__FILE__), 'model/simple.xml')
 
@@ -21,26 +21,29 @@ class TC_XML_Reader < Test::Unit::TestCase
     verify_simple(reader)
   end
 
-  def test_reader_error
-    reader = XML::Reader.new('<foo/>')
-    assert_raises(RuntimeError) { reader.set_error_handler }
+  def test_deprecated_error_handler
     called = false
-    reader.set_error_handler { |*a| called = true }
-    while reader.read > 0; end
-    assert(!called)
     reader = XML::Reader.new('<foo blah')
-    reader.set_error_handler do |*a|
-      assert_equal(5, a.size)
-      assert_equal(reader, a[0])
-      assert_equal(XML::Reader::SEVERITY_ERROR, a[2])
-      assert_nil(a[3])
-      assert_equal(1, a[4])
+    reader.set_error_handler do |error|
       called = true
     end
-    while reader.read > 0; end
+
+    reader.read
     assert(called)
   end
 
+  def test_deprecated_reset_error_handler
+    called = false
+    reader = XML::Reader.new('<foo blah')
+    reader.set_error_handler do |error|
+      called = true
+    end
+    reader.reset_error_handler
+
+    reader.read
+    assert(!called)
+  end
+
   def test_attr
     parser = XML::Reader.new("<foo x='1' y='2'/>")
     assert_equal(1, parser.read)
@@ -109,4 +112,11 @@ class TC_XML_Reader < Test::Unit::TestCase
        XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
        XML::Reader::TYPE_END_ELEMENT])
   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
 end

data/test/tc_relaxng.rb

@@ -28,12 +28,24 @@ class TestRelaxNG < Test::Unit::TestCase
     new_node = XML::Node.new('invalid', 'this will mess up validation')
     @doc.root.child_add(new_node)
     
-    messages = Hash.new
-    assert(!@doc.validate_relaxng(relaxng) do |message, error|
-      messages[message] = error
-    end)
+    error = assert_raise(XML::Error) do
+      @doc.validate_relaxng(relaxng)
+    end
 
-    expected = {"Did not expect element invalid there\n" => true}
-    assert_equal(expected, messages)
+    assert_not_nil(error)
+    assert_kind_of(XML::Error, error)
+    assert(error.message.match(/Error: Did not expect element invalid there at/))
+    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

@@ -1,7 +1,11 @@
 require 'xml'
 require 'test/unit'
 
-# TODO this is woefully inadequate
+class DocTypeCallback
+  include XML::SaxParser::Callbacks
+  def on_start_element(element, attributes)
+  end
+end
 
 class TestCaseCallbacks
   include XML::SaxParser::Callbacks
@@ -56,7 +60,6 @@ class TestSaxParser < Test::Unit::TestCase
   end
 
   def verify
-    @xp.parse
     assert_equal [1], @xp.callbacks.test[:startdoc]
     assert_equal [[2,'test',{'uga'=>'booga','foo'=>'bar'}],[3,'fixnum',{}],[6,'fixnum',{}]],
                  @xp.callbacks.test[:startel]
@@ -75,30 +78,62 @@ class TestSaxParser < Test::Unit::TestCase
   end
 
   def test_file_without_callbacks
-    @xp.filename = File.join(File.dirname(__FILE__), 'model/saxtest.xml')
+    @xp.file = File.join(File.dirname(__FILE__), 'model/saxtest.xml')
     assert_equal true, @xp.parse
   end
 
-  def test_callbacks_with_string
+  def test_string_with_callbacks
     @xp.callbacks = TestCaseCallbacks.new
     @xp.string = File.read(File.join(File.dirname(__FILE__), 'model/saxtest.xml'))
+    @xp.parse
     verify
   end
 
-  def test_callbacks_with_file
+  def test_file_with_callbacks
     @xp.callbacks = TestCaseCallbacks.new
-    @xp.filename = File.join(File.dirname(__FILE__), 'model/saxtest.xml')
+    @xp.file = File.join(File.dirname(__FILE__), 'model/saxtest.xml')
+    @xp.parse
     verify
   end
 
   def test_doctype
+    @xp.callbacks = DocTypeCallback.new
+    @xp.string = <<-EOS
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE Results SYSTEM "results.dtd">
+<Results>
+  <a>a1</a>
+</Results>
+EOS
+    doc = @xp.parse
+    assert_not_nil(doc)
+  end
+
+  def test_parse_error
     @xp.callbacks = TestCaseCallbacks.new
     @xp.string = <<-EOS
-      <?xml version="1.0" encoding="UTF-8"?>
-      <!DOCTYPE ONIXmessage SYSTEM "http://www.editeur.org/onix/2.1/short/onix-international.dtd">
-      <ONIXmessage release="2.1">
-      </ONIXmessage>
+      <Results>
+        <a>a1
+      </Results>
     EOS
-    @xp.parse
-  end
-end # TC_XML_Sax_Parser
+
+    error = assert_raise(XML::Error) do
+      doc = @xp.parse
+    end
+
+    assert_not_nil(error)
+    assert_kind_of(XML::Error, error)
+    assert_equal("Fatal error: Premature end of data in tag Results line 1 at :4.", 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(4, 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

data/test/tc_schema.rb

@@ -1,4 +1,4 @@
-require "xml"
+require 'xml'
 require 'test/unit'
 
 class TestSchema < Test::Unit::TestCase
@@ -27,13 +27,25 @@ class TestSchema < Test::Unit::TestCase
   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_schema(schema) do |message, error|
-      messages[message] = error
-    end)
 
-    expected = {"Element 'invalid': This element is not expected. Expected is ( item ).\n" => true}
-    assert_equal(expected, messages)
+    error = assert_raise(XML::Error) do
+      @doc.validate_schema(schema)
+    end
+
+    assert_not_nil(error)
+    assert_kind_of(XML::Error, error)
+    assert(error.message.match(/Error: Element 'invalid': This element is not expected. Expected is \( item \)\. at/))
+    assert_equal(XML::Error::SCHEMASV, error.domain)
+    assert_equal(XML::Error::SCHEMAV_ELEMENT_CONTENT, error.code)
+    assert_equal(XML::Error::ERROR, error.level)
+    assert(error.file.match(/shiporder.xml/))
+    assert_nil(error.line)
+    assert_nil(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_well_formed.rb

@@ -1,10 +1,11 @@
-require "libxml"
+require 'xml'
 require 'test/unit'
 
 class TestWellFormed < Test::Unit::TestCase
   def test_xml_node_doc_get()
     parser = XML::Parser.new
     parser.string = "<p>I am well formed</p>"
+    parser.parse
     assert(parser.context.well_formed?)
   end
 end

data/test/tc_xml.rb

@@ -0,0 +1,212 @@
+require 'xml'
+require 'test/unit'
+require 'stringio'
+
+class TestXml < Test::Unit::TestCase
+  # -----  Constants  ------
+  def test_lib_versions
+    assert(XML.check_lib_versions)
+  end
+
+  def test_debug_entities
+    XML.debug_entities = false
+    assert(!XML.debug_entities)
+
+    XML.debug_entities = true
+    assert(XML.debug_entities)
+
+    XML.debug_entities = false
+    assert(!XML.debug_entities)
+  end
+
+  def test_default_compression
+    return unless XML.default_compression
+
+    0.upto(9) do |i|
+      XML.default_compression = i
+      assert_equal(i, XML.default_compression)
+    end
+
+    9.downto(0) do |i|
+      assert_equal(i, XML.default_compression = i)
+      assert_equal(i, XML.default_compression)
+    end
+
+    0.downto(-10) do |i|
+      assert_equal(i, XML.default_compression = i)
+      assert_equal(0, XML.default_compression)
+    end
+
+    10.upto(20) do |i|
+      assert_equal(i, XML.default_compression = i)
+      assert_equal(9, XML.default_compression)
+    end
+  end
+
+  def test_default_keep_blanks
+    XML.default_keep_blanks = false
+    assert(!XML.default_keep_blanks)
+
+    XML.default_keep_blanks = true
+    assert(XML.default_keep_blanks)
+
+    XML.default_keep_blanks = false
+    assert(!XML.default_keep_blanks)
+
+    # other tests depend on keeping blanks by default,
+    # which is the default default behaviour anyway.
+    XML.default_keep_blanks = true
+  end
+
+  def test_default_line_numbers
+    XML.default_line_numbers = false
+    assert(!XML.default_line_numbers)
+
+    XML.default_line_numbers = true
+    assert(XML.default_line_numbers)
+
+    XML.default_line_numbers = false
+    assert(!XML.default_line_numbers)
+  end
+
+  def test_default_substitute_entities
+    XML.default_substitute_entities = false
+    assert(!XML.default_substitute_entities)
+
+    XML.default_substitute_entities = true
+    assert(XML.default_substitute_entities)
+
+    XML.default_substitute_entities = false
+    assert(!XML.default_substitute_entities)
+  end
+
+  def test_default_tree_indent_string
+    s = XML.default_tree_indent_string
+    assert_instance_of(String, s)
+    assert_equal('  ', s)
+    XML.default_tree_indent_string = 'uga'
+    s = XML.default_tree_indent_string
+    assert_instance_of(String, s)
+    assert_equal('uga', s)
+    XML.default_tree_indent_string = '  '
+    s = XML.default_tree_indent_string
+    assert_instance_of(String, s)
+    assert_equal('  ', s)
+  end
+
+  def test_default_validity_checking
+    XML.default_validity_checking = false
+    assert(!XML.default_validity_checking)
+
+    XML.default_validity_checking = true
+    assert(XML.default_validity_checking)
+
+    XML.default_validity_checking = false
+    assert(!XML.default_validity_checking)
+  end
+
+  def test_default_warnings
+    XML.default_warnings = false
+    assert(!XML.default_warnings)
+
+    XML.default_warnings = true
+    assert(XML.default_warnings)
+
+    XML.default_warnings = false
+    assert(!XML.default_warnings)
+  end
+
+  def test_enabled_automata
+    assert_equal(true, XML.enabled_automata?)
+  end
+
+  def test_enabled_c14n
+    assert_equal(true, XML.enabled_c14n?)
+  end
+
+  def test_enabled_catalog
+    assert_equal(true, XML.enabled_catalog?)
+  end
+
+  def test_enabled_debug
+    assert_equal(true, XML.enabled_debug?)
+  end
+
+  def test_enabled_docbook
+    assert_equal(true, XML.enabled_docbook?)
+  end
+
+  def test_enabled_ftp
+    assert_equal(true, XML.enabled_ftp?)
+  end
+
+  def test_enabled_http
+    assert_equal(true, XML.enabled_http?)
+  end
+
+  def test_enabled_html
+    assert_equal(true, XML.enabled_html?)
+  end
+
+  def test_enabled_iconv
+    assert_equal(true, XML.enabled_iconv?)
+  end
+
+  def test_enabled_memory_debug
+    assert_equal(false, XML.enabled_memory_debug?)
+  end
+
+  def test_enabled_regexp
+    assert_equal(true, XML.enabled_regexp?)
+  end
+
+  def test_enabled_schemas
+    assert_equal(true, XML.enabled_schemas?)
+  end
+
+  def test_enabled_thread
+    assert_equal(true, XML.enabled_thread?)
+  end
+
+  def test_enabled_unicode
+    assert_equal(true, XML.enabled_unicode?)
+  end
+
+  def test_enabled_xinclude
+    assert_equal(true, XML.enabled_xinclude?)
+  end
+
+  def test_enabled_xpath
+    assert_equal(true, XML.enabled_xpath?)
+  end
+
+  def test_enabled_xpointer
+    assert_equal(true, XML.enabled_xpointer?)
+  end
+
+  def test_enabled_zlib
+    assert_equal(true, XML.enabled_zlib?)
+  end
+
+  def test_intent_tree_output
+    assert(TrueClass, XML.indent_tree_output)
+
+    XML.indent_tree_output = false
+    assert(FalseClass, XML.indent_tree_output)
+
+    XML.indent_tree_output = true
+    assert(TrueClass, XML.indent_tree_output)
+  end
+
+  def test_version
+    assert_instance_of(String, XML::VERSION)
+  end
+
+  def test_vernum
+    assert_instance_of(Fixnum, XML::VERNUM)
+  end
+
+  def test_libxml_parser_features
+    assert_instance_of(Array, XML.features)
+  end
+end