libxml-ruby 2.8.0 → 3.2.1

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,7 +180,7 @@ 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
@@ -189,8 +188,8 @@ class TestSaxParser < Test::Unit::TestCase
   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,11 +239,11 @@ 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
@@ -255,21 +254,21 @@ EOS
     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("error: Fatal error: EndTag: '</' not found 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)
+    refute_nil(error)
+    assert_kind_of(LibXML::XML::Error, error)
+    assert_equal("Fatal error: EndTag: '</' not found at :2.", error.message)
+    assert_equal(LibXML::XML::Error::PARSER, error.domain)
+    assert_equal(LibXML::XML::Error::LTSLASH_REQUIRED, error.code)
+    assert_equal(LibXML::XML::Error::FATAL, error.level)
     assert_nil(error.file)
     assert_equal(2, error.line)
-    assert_equal('Results', error.str1)
+    assert_nil(error.str1)
     assert_nil(error.str2)
     assert_nil(error.str3)
-    assert_equal(1, error.int1)
+    assert_equal(0, error.int1)
     assert_equal(1, error.int2)
     assert_nil(error.node)
   end
@@ -306,15 +305,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

data/test/{tc_schema.rb → test_schema.rb}

@@ -1,12 +1,11 @@
 # encoding: UTF-8
 
-require './test_helper'
-require 'test/unit'
+require_relative './test_helper'
 
-class TestSchema < Test::Unit::TestCase
+class TestSchema < Minitest::Test
   def setup
     file = File.join(File.dirname(__FILE__), 'model/shiporder.xml')
-    @doc = XML::Document.file(file)
+    @doc = LibXML::XML::Document.file(file)
   end
 
   def teardown
@@ -14,17 +13,17 @@ class TestSchema < Test::Unit::TestCase
   end
 
   def schema
-    document = XML::Document.file(File.join(File.dirname(__FILE__), 'model/shiporder.xsd'))
-    XML::Schema.document(document)
+    document = LibXML::XML::Document.file(File.join(File.dirname(__FILE__), 'model/shiporder.xsd'))
+    LibXML::XML::Schema.document(document)
   end
 
   def check_error(error)
-    assert_not_nil(error)
+    refute_nil(error)
     assert(error.message.match(/Error: Element 'invalid': This element is not expected. Expected is \( item \)/))
-    assert_kind_of(XML::Error, error)
-    assert_equal(XML::Error::SCHEMASV, error.domain)
-    assert_equal(XML::Error::SCHEMAV_ELEMENT_CONTENT, error.code)
-    assert_equal(XML::Error::ERROR, error.level)
+    assert_kind_of(LibXML::XML::Error, error)
+    assert_equal(LibXML::XML::Error::SCHEMASV, error.domain)
+    assert_equal(LibXML::XML::Error::SCHEMAV_ELEMENT_CONTENT, error.code)
+    assert_equal(LibXML::XML::Error::ERROR, error.level)
     assert(error.file.match(/shiporder.xml/)) if error.file
     assert_nil(error.str1)
     assert_nil(error.str2)
@@ -34,7 +33,7 @@ class TestSchema < Test::Unit::TestCase
   end
 
   def test_load_from_doc
-    assert_instance_of(XML::Schema, schema)
+    assert_instance_of(LibXML::XML::Schema, schema)
   end
 
   def test_doc_valid
@@ -42,21 +41,21 @@ class TestSchema < Test::Unit::TestCase
   end
 
   def test_doc_invalid
-    new_node = XML::Node.new('invalid', 'this will mess up validation')
+    new_node = LibXML::XML::Node.new('invalid', 'this will mess up validation')
     @doc.root << new_node
 
-    error = assert_raise(XML::Error) do
+    error = assert_raises(LibXML::XML::Error) do
       @doc.validate_schema(schema)
     end
 
     check_error(error)
     assert_nil(error.line)
-    assert_not_nil(error.node)
+    refute_nil(error.node)
     assert_equal('invalid', error.node.name)
   end
 
   def test_reader_valid
-    reader = XML::Reader.string(@doc.to_s)
+    reader = LibXML::XML::Reader.string(@doc.to_s)
     assert(reader.schema_validate(schema))
 
     while reader.read
@@ -66,13 +65,13 @@ class TestSchema < Test::Unit::TestCase
   def test_reader_invalid
     # Set error handler
     errors = Array.new
-    XML::Error.set_handler do |error|
+    LibXML::XML::Error.set_handler do |error|
       errors << error
     end
 
-    new_node = XML::Node.new('invalid', 'this will mess up validation')
+    new_node = LibXML::XML::Node.new('invalid', 'this will mess up validation')
     @doc.root << new_node
-    reader = XML::Reader.string(@doc.to_s)
+    reader = LibXML::XML::Reader.string(@doc.to_s)
 
     # Set a schema
     assert(reader.schema_validate(schema))
@@ -86,35 +85,45 @@ class TestSchema < Test::Unit::TestCase
     check_error(error)
     assert_equal(21, error.line)
   ensure
-    XML::Error.set_handler(&LibXML::XML::Error::VERBOSE_HANDLER)
+    LibXML::XML::Error.set_handler(&LibXML::XML::Error::VERBOSE_HANDLER)
   end
 
 
   # Schema meta-data tests
-
   def test_elements
     assert_instance_of(Hash, schema.elements)
     assert_equal(1, schema.elements.length)
-    assert_instance_of(XML::Schema::Element, schema.elements['shiporder'])
+    assert_instance_of(LibXML::XML::Schema::Element, schema.elements['shiporder'])
   end
 
   def test_types
     assert_instance_of(Hash, schema.types)
     assert_equal(1, schema.types.length)
-    assert_instance_of(XML::Schema::Type, schema.types['shiporder'])
+    assert_instance_of(LibXML::XML::Schema::Type, schema.types['shiporder'])
+  end
+
+  def test_imported_types
+    assert_instance_of(Hash, schema.imported_types)
+    assert_equal(1, schema.imported_types.length)
+    assert_instance_of(LibXML::XML::Schema::Type, schema.types['shiporder'])
+  end
+
+  def test_namespaces
+    assert_instance_of(Array, schema.namespaces)
+    assert_equal(1, schema.namespaces.length)
   end
 
   def test_schema_type
     type = schema.types['shiporder']
 
     assert_equal('shiporder', type.name)
-    assert_equal(nil, type.namespace)
+    assert_nil(type.namespace)
     assert_equal("Shiporder type documentation", type.annotation)
-    assert_instance_of(XML::Node, type.node)
-    assert_equal(XML::Schema::Types::XML_SCHEMA_TYPE_COMPLEX, type.kind)
-    assert_instance_of(XML::Schema::Type, type.base)
+    assert_instance_of(LibXML::XML::Node, type.node)
+    assert_equal(LibXML::XML::Schema::Types::XML_SCHEMA_TYPE_COMPLEX, type.kind)
+    assert_instance_of(LibXML::XML::Schema::Type, type.base)
     assert_equal("anyType", type.base.name)
-    assert_equal(XML::Schema::Types::XML_SCHEMA_TYPE_BASIC, type.base.kind)
+    assert_equal(LibXML::XML::Schema::Types::XML_SCHEMA_TYPE_BASIC, type.base.kind)
 
     assert_instance_of(Hash, type.elements)
     assert_equal(3, type.elements.length)
@@ -124,17 +133,14 @@ class TestSchema < Test::Unit::TestCase
     element = schema.types['shiporder'].elements['orderperson']
 
     assert_equal('orderperson', element.name)
-    assert_equal(nil, element.namespace)
+    assert_nil(element.namespace)
     assert_equal("orderperson element documentation", element.annotation)
-    assert_equal(1, element.min_occurs)
-    assert_equal(1, element.max_occurs)
-
 
     element = schema.types['shiporder'].elements['item']
-    assert_equal(Float::INFINITY, element.max_occurs)
+    assert_equal('item', element.name)
 
     element = schema.types['shiporder'].elements['item'].type.elements['note']
-    assert_equal(0, element.min_occurs)
+    assert_equal('note', element.name)
     assert_equal('string', element.type.name)
   end
 
@@ -143,14 +149,14 @@ class TestSchema < Test::Unit::TestCase
 
     assert_instance_of(Array, type.attributes)
     assert_equal(2, type.attributes.length)
-    assert_instance_of(XML::Schema::Attribute, type.attributes.first)
+    assert_instance_of(LibXML::XML::Schema::Attribute, type.attributes.first)
   end
 
   def test_schema_attribute
     attribute = schema.types['shiporder'].attributes.first
 
     assert_equal("orderid", attribute.name)
-    assert_equal(nil, attribute.namespace)
+    assert_nil(attribute.namespace)
     assert_equal(1, attribute.occurs)
     assert_equal('string', attribute.type.name)
 
@@ -159,4 +165,4 @@ class TestSchema < Test::Unit::TestCase
     assert_equal('1', attribute.default)
     assert_equal('integer', attribute.type.name)
   end
-end
+end

data/test/test_suite.rb

@@ -5,46 +5,44 @@
 dir = File.dirname(__FILE__)
 Dir.chdir(dir)
 
-require './tc_attr'
-require './tc_attr_decl'
-require './tc_attributes'
-require './tc_canonicalize'
-require './tc_document'
-require './tc_document_write'
-require './tc_dtd'
-require './tc_error'
-require './tc_html_parser'
-require './tc_html_parser_context'
-require './tc_namespace'
-require './tc_namespaces'
-require './tc_node'
-require './tc_node_cdata'
-require './tc_node_comment'
-require './tc_node_copy'
-require './tc_node_edit'
-require './tc_node_pi'
-require './tc_node_text'
-require './tc_node_write'
-require './tc_node_xlink'
-require './tc_parser'
-require './tc_parser_context'
-require './tc_reader'
-require './tc_relaxng'
-require './tc_sax_parser'
-require './tc_schema'
-require './tc_traversal'
-require './tc_writer'
-require './tc_xinclude'
-require './tc_xpath'
-require './tc_xpath_context'
-require './tc_xpath_expression'
-require './tc_xpointer'
+require './test_attr'
+require './test_attr_decl'
+require './test_attributes'
+require './test_canonicalize'
+require './test_document'
+require './test_document_write'
+require './test_dtd'
+require './test_error'
+require './test_html_parser'
+require './test_html_parser_context'
+require './test_namespace'
+require './test_namespaces'
+require './test_node'
+require './test_node_cdata'
+require './test_node_comment'
+require './test_node_copy'
+require './test_node_edit'
+require './test_node_pi'
+require './test_node_text'
+require './test_node_write'
+require './test_node_xlink'
+require './test_parser'
+require './test_parser_context'
+require './test_reader'
+require './test_relaxng'
+require './test_sax_parser'
+require './test_schema'
+require './test_traversal'
+require './test_writer'
+require './test_xinclude'
+require './test_xpath'
+require './test_xpath_context'
+require './test_xpath_expression'
+require './test_xpointer'
 
+require './test_encoding'
+require './test_encoding_sax'
 
-if defined?(Encoding)
-  require './tc_encoding'
-  require './tc_encoding_sax'
-end
 # Compatibility
-require './tc_properties'
-require './tc_deprecated_require'
+require './test_properties'
+require './test_deprecated_require'