libxml-ruby 3.0.0 → 3.2.2

data/test/{tc_parser.rb → test_parser.rb}

@@ -1,47 +1,47 @@
 # encoding: UTF-8
 
-require './test_helper'
+require_relative './test_helper'
 require 'stringio'
 
 class TestParser < Minitest::Test
   def setup
-    XML::Error.set_handler(&XML::Error::QUIET_HANDLER)
+    LibXML::XML::Error.set_handler(&LibXML::XML::Error::QUIET_HANDLER)
   end
 
   # -----  Sources  -------
   def test_document
     file = File.expand_path(File.join(File.dirname(__FILE__), 'model/bands.utf-8.xml'))
-    parser = XML::Parser.file(file)
+    parser = LibXML::XML::Parser.file(file)
     doc = parser.parse
 
-    parser = XML::Parser.document(doc)
+    parser = LibXML::XML::Parser.document(doc)
 
     doc = parser.parse
 
-    assert_instance_of(XML::Document, doc)
-    assert_instance_of(XML::Parser::Context, parser.context)
+    assert_instance_of(LibXML::XML::Document, doc)
+    assert_instance_of(LibXML::XML::Parser::Context, parser.context)
   end
 
   def test_nil_document
     error = assert_raises(TypeError) do
-      XML::Parser.document(nil)
+      LibXML::XML::Parser.document(nil)
     end
 
-    assert_equal("Must pass an XML::Document object", error.to_s)
+    assert_equal("Must pass an LibXML::XML::Document object", error.to_s)
   end
 
   def test_file
     file = File.expand_path(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
 
-    parser = XML::Parser.file(file)
+    parser = LibXML::XML::Parser.file(file)
     doc = parser.parse
-    assert_instance_of(XML::Document, doc)
-    assert_instance_of(XML::Parser::Context, parser.context)
+    assert_instance_of(LibXML::XML::Document, doc)
+    assert_instance_of(LibXML::XML::Parser::Context, parser.context)
   end
 
   def test_noexistent_file
-    error = assert_raises(XML::Error) do
-      XML::Parser.file('i_dont_exist.xml')
+    error = assert_raises(LibXML::XML::Error) do
+      LibXML::XML::Parser.file('i_dont_exist.xml')
     end
 
     assert_equal('Warning: failed to load external entity "i_dont_exist.xml".', error.to_s)
@@ -49,7 +49,7 @@ class TestParser < Minitest::Test
 
   def test_nil_file
     error = assert_raises(TypeError) do
-      XML::Parser.file(nil)
+      LibXML::XML::Parser.file(nil)
     end
 
     assert_match(/nil into String/, error.to_s)
@@ -57,15 +57,15 @@ class TestParser < Minitest::Test
 
   def test_file_encoding
     file = File.expand_path(File.join(File.dirname(__FILE__), 'model/bands.utf-8.xml'))
-    parser = XML::Parser.file(file, :encoding => XML::Encoding::ISO_8859_1)
+    parser = LibXML::XML::Parser.file(file, :encoding => LibXML::XML::Encoding::ISO_8859_1)
 
-    error = assert_raises(XML::Error) do
-      doc = parser.parse
+    error = assert_raises(LibXML::XML::Error) do
+      parser.parse
     end
 
     assert(error.to_s.match(/Fatal error: Extra content at the end of the document/))
 
-    parser = XML::Parser.file(file, :encoding => XML::Encoding::UTF_8)
+    parser = LibXML::XML::Parser.file(file, :encoding => LibXML::XML::Encoding::UTF_8)
     doc = parser.parse
     refute_nil(doc)
   end
@@ -73,23 +73,23 @@ class TestParser < Minitest::Test
   def test_file_base_uri
     file = File.expand_path(File.join(File.dirname(__FILE__), 'model/bands.utf-8.xml'))
 
-    parser = XML::Parser.file(file)
+    parser = LibXML::XML::Parser.file(file)
     doc = parser.parse
     assert(doc.child.base_uri.match(/test\/model\/bands.utf-8.xml/))
 
-    parser = XML::Parser.file(file, :base_uri => "http://libxml.org")
+    parser = LibXML::XML::Parser.file(file, :base_uri => "http://libxml.org")
     doc = parser.parse
     assert(doc.child.base_uri.match(/test\/model\/bands.utf-8.xml/))
   end
 
   def test_io
     File.open(File.join(File.dirname(__FILE__), 'model/rubynet.xml')) do |io|
-      parser = XML::Parser.io(io)
-      assert_instance_of(XML::Parser, parser)
+      parser = LibXML::XML::Parser.io(io)
+      assert_instance_of(LibXML::XML::Parser, parser)
 
       doc = parser.parse
-      assert_instance_of(XML::Document, doc)
-      assert_instance_of(XML::Parser::Context, parser.context)
+      assert_instance_of(LibXML::XML::Document, doc)
+      assert_instance_of(LibXML::XML::Parser::Context, parser.context)
     end
   end
 
@@ -97,7 +97,7 @@ class TestParser < Minitest::Test
     # Test that the reader keeps a reference
     # to the io object
     file = File.open(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
-    parser = XML::Parser.io(file)
+    parser = LibXML::XML::Parser.io(file)
     file = nil
     GC.start
     assert(parser.parse)
@@ -105,7 +105,7 @@ class TestParser < Minitest::Test
 
   def test_nil_io
     error = assert_raises(TypeError) do
-      XML::Parser.io(nil)
+      LibXML::XML::Parser.io(nil)
     end
 
     assert_equal("Must pass in an IO object", error.to_s)
@@ -114,22 +114,22 @@ class TestParser < Minitest::Test
   def test_string_io
     data = File.read(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
     string_io = StringIO.new(data)
-    parser = XML::Parser.io(string_io)
+    parser = LibXML::XML::Parser.io(string_io)
 
     doc = parser.parse
-    assert_instance_of(XML::Document, doc)
-    assert_instance_of(XML::Parser::Context, parser.context)
+    assert_instance_of(LibXML::XML::Document, doc)
+    assert_instance_of(LibXML::XML::Parser::Context, parser.context)
   end
 
   def test_string_io_thread
     thread = Thread.new do
       data = File.read(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
       string_io = StringIO.new(data)
-      parser = XML::Parser.io(string_io)
+      parser = LibXML::XML::Parser.io(string_io)
 
       doc = parser.parse
-      assert_instance_of(XML::Document, doc)
-      assert_instance_of(XML::Parser::Context, parser.context)
+      assert_instance_of(LibXML::XML::Document, doc)
+      assert_instance_of(LibXML::XML::Parser::Context, parser.context)
     end
 
     thread.join
@@ -140,17 +140,17 @@ class TestParser < Minitest::Test
   def test_string
     str = '<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
 
-    parser = XML::Parser.string(str)
-    assert_instance_of(XML::Parser, parser)
+    parser = LibXML::XML::Parser.string(str)
+    assert_instance_of(LibXML::XML::Parser, parser)
 
     doc = parser.parse
-    assert_instance_of(XML::Document, doc)
-    assert_instance_of(XML::Parser::Context, parser.context)
+    assert_instance_of(LibXML::XML::Document, doc)
+    assert_instance_of(LibXML::XML::Parser::Context, parser.context)
   end
 
   def test_nil_string
     error = assert_raises(TypeError) do
-      XML::Parser.string(nil)
+      LibXML::XML::Parser.string(nil)
     end
 
     assert_equal("wrong argument type nil (expected String)", error.to_s)
@@ -165,30 +165,30 @@ class TestParser < Minitest::Test
       </test>
     EOS
 
-    XML::default_substitute_entities = false
+    LibXML::XML::default_substitute_entities = false
 
     # Parse normally
-    parser = XML::Parser.string(xml)
+    parser = LibXML::XML::Parser.string(xml)
     doc = parser.parse
     assert_nil(doc.child.base_uri)
 
     # Cdata section should be cdata nodes
     node = doc.find_first('/test/cdata').child
-    assert_equal(XML::Node::CDATA_SECTION_NODE, node.node_type)
+    assert_equal(LibXML::XML::Node::CDATA_SECTION_NODE, node.node_type)
 
     # Entities should not be subtituted
     node = doc.find_first('/test/entity')
     assert_equal('&foo;', node.child.to_s)
 
     # Parse with options
-    parser = XML::Parser.string(xml, :base_uri => 'http://libxml.rubyforge.org',
-                                     :options => XML::Parser::Options::NOCDATA | XML::Parser::Options::NOENT)
+    parser = LibXML::XML::Parser.string(xml, :base_uri => 'http://libxml.rubyforge.org',
+                                     :options => LibXML::XML::Parser::Options::NOCDATA | LibXML::XML::Parser::Options::NOENT)
     doc = parser.parse
     assert_equal(doc.child.base_uri, 'http://libxml.rubyforge.org')
 
     # Cdata section should be text nodes
     node = doc.find_first('/test/cdata').child
-    assert_equal(XML::Node::TEXT_NODE, node.node_type)
+    assert_equal(LibXML::XML::Node::TEXT_NODE, node.node_type)
 
     # Entities should be subtituted
     node = doc.find_first('/test/entity')
@@ -207,25 +207,21 @@ class TestParser < Minitest::Test
     EOS
 
     # Parse as UTF_8
-    parser = XML::Parser.string(xml, :encoding => XML::Encoding::UTF_8)
+    parser = LibXML::XML::Parser.string(xml, :encoding => LibXML::XML::Encoding::UTF_8)
 
-    error = assert_raises(XML::Error) do
-      doc = parser.parse
+    error = assert_raises(LibXML::XML::Error) do
+      parser.parse
     end
 
     assert_equal("Fatal error: Input is not proper UTF-8, indicate encoding !\nBytes: 0xF6 0x74 0x6C 0x65 at :2.",
                  error.to_s)
 
     # Parse as ISO_8859_1:
-    parser = XML::Parser.string(xml, :encoding => XML::Encoding::ISO_8859_1)
+    parser = LibXML::XML::Parser.string(xml, :encoding => LibXML::XML::Encoding::ISO_8859_1)
     doc = parser.parse
     node = doc.find_first('//metal')
-    if defined?(Encoding)
-      assert_equal(Encoding::UTF_8, node.content.encoding)
-      assert_equal("m\303\266tley_cr\303\274e", node.content)
-    else
-      assert_equal("m\303\266tley_cr\303\274e", node.content)
-    end
+    assert_equal(Encoding::UTF_8, node.content.encoding)
+    assert_equal("m\303\266tley_cr\303\274e", node.content)
   end
 
   def test_fd_gc
@@ -235,9 +231,9 @@ class TestParser < Minitest::Test
     # 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::Error.set_handler {|error|}
+    LibXML::XML::Error.set_handler {|error|}
 
-    max_fd = if RUBY_PLATFORM.match(/mswin32|mingw/i)
+    max_fd = if RUBY_PLATFORM.match(/mswin32|mswin64|mingw/i)
       500
     else
       Process.getrlimit(Process::RLIMIT_NOFILE)[0] + 1
@@ -245,51 +241,52 @@ class TestParser < Minitest::Test
 
     file = File.join(File.dirname(__FILE__), 'model/rubynet.xml')
     max_fd.times do
-       XML::Parser.file(file).parse
+       LibXML::XML::Parser.file(file).parse
     end
-    XML::Error.reset_handler {|error|}
+    LibXML::XML::Error.reset_handler {|error|}
   end
 
   def test_open_many_files
+    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/atom.xml'))
     1000.times do
-      doc = XML::Parser.file('model/atom.xml').parse
+      LibXML::XML::Parser.file(file).parse
     end
   end
 
   # -----  Errors  ------
   def test_error
-    error = assert_raises(XML::Error) do
-      XML::Parser.string('<foo><bar/></foz>').parse
+    error = assert_raises(LibXML::XML::Error) do
+      LibXML::XML::Parser.string('<foo><bar/></foz>').parse
     end
 
     refute_nil(error)
-    assert_kind_of(XML::Error, error)
+    assert_kind_of(LibXML::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_equal(LibXML::XML::Error::PARSER, error.domain)
+    assert_equal(LibXML::XML::Error::TAG_NAME_MISMATCH, error.code)
+    assert_equal(LibXML::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([18, 20].include?(error.int2))
     assert_nil(error.node)
   end
 
   def test_bad_xml
-    parser = XML::Parser.string('<ruby_array uga="booga" foo="bar"<fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>')
-    error = assert_raises(XML::Error) do
+    parser = LibXML::XML::Parser.string('<ruby_array uga="booga" foo="bar"<fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>')
+    error = assert_raises(LibXML::XML::Error) do
       refute_nil(parser.parse)
     end
 
     refute_nil(error)
-    assert_kind_of(XML::Error, error)
+    assert_kind_of(LibXML::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_equal(LibXML::XML::Error::PARSER, error.domain)
+    assert_equal(LibXML::XML::Error::DOCUMENT_END, error.code)
+    assert_equal(LibXML::XML::Error::FATAL, error.level)
     assert_nil(error.file)
     assert_equal(1, error.line)
     assert_nil(error.str1)
@@ -305,20 +302,20 @@ class TestParser < Minitest::Test
     background_errors = []
 
     begin
-      XML::Error.set_handler do |error|
+      LibXML::XML::Error.set_handler do |error|
         errors << error
       end
-      parser = XML::Parser.string("<moo>")
+      parser = LibXML::XML::Parser.string("<moo>")
 
       thread = Thread.new do
-        XML::Error.set_handler do |error|
+        LibXML::XML::Error.set_handler do |error|
           background_errors << error
         end
         parser.parse rescue nil
       end
       thread.join
     ensure
-      XML::Error.set_handler(&XML::Error::QUIET_HANDLER)
+      LibXML::XML::Error.set_handler(&LibXML::XML::Error::QUIET_HANDLER)
     end
 
     assert_equal(errors.size, 0)

data/test/{tc_parser_context.rb → test_parser_context.rb}

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 
-require './test_helper'
+require_relative './test_helper'
 
 
 class TestParserContext < Minitest::Test
@@ -12,9 +12,9 @@ class TestParserContext < Minitest::Test
       </bands>
     EOS
 
-    context = XML::Parser::Context.string(xml)
-    assert_instance_of(XML::Parser::Context, context)
-    assert_equal(XML::Encoding::NONE, context.encoding)
+    context = LibXML::XML::Parser::Context.string(xml)
+    assert_instance_of(LibXML::XML::Parser::Context, context)
+    assert_equal(LibXML::XML::Encoding::NONE, context.encoding)
     assert_nil(context.base_uri)
   end
 
@@ -26,11 +26,11 @@ class TestParserContext < Minitest::Test
       </bands>
     EOS
 
-    context = XML::Parser::Context.string(xml)
-    assert_equal(XML::Encoding::NONE, context.encoding)
+    context = LibXML::XML::Parser::Context.string(xml)
+    assert_equal(LibXML::XML::Encoding::NONE, context.encoding)
 
-    context.encoding = XML::Encoding::ISO_8859_1
-    assert_equal(XML::Encoding::ISO_8859_1, context.encoding)
+    context.encoding = LibXML::XML::Encoding::ISO_8859_1
+    assert_equal(LibXML::XML::Encoding::ISO_8859_1, context.encoding)
   end
 
   def test_invalid_encoding
@@ -41,7 +41,7 @@ class TestParserContext < Minitest::Test
       </bands>
     EOS
 
-    context = XML::Parser::Context.string(xml)
+    context = LibXML::XML::Parser::Context.string(xml)
 
     error = assert_raises(ArgumentError) do
       context.encoding = -999
@@ -57,7 +57,7 @@ class TestParserContext < Minitest::Test
       </bands>
     EOS
 
-    context = XML::Parser::Context.string(xml)
+    context = LibXML::XML::Parser::Context.string(xml)
     assert_nil(context.base_uri)
 
     context.base_uri = 'http://libxml.rubyforge.org'
@@ -66,25 +66,25 @@ class TestParserContext < Minitest::Test
 
   def test_string_empty
     error = assert_raises(TypeError) do
-      XML::Parser::Context.string(nil)
+      LibXML::XML::Parser::Context.string(nil)
     end
     assert_equal("wrong argument type nil (expected String)", error.to_s)
 
     error = assert_raises(ArgumentError) do
-      XML::Parser::Context.string('')
+      LibXML::XML::Parser::Context.string('')
     end
     assert_equal("Must specify a string with one or more characters", error.to_s)
   end
 
   def test_well_formed
-    parser = XML::Parser.string("<abc/>")
+    parser = LibXML::XML::Parser.string("<abc/>")
     parser.parse
     assert(parser.context.well_formed?)
   end
 
   def test_not_well_formed
-    parser = XML::Parser.string("<abc>")
-    assert_raises(XML::Error) do
+    parser = LibXML::XML::Parser.string("<abc>")
+    assert_raises(LibXML::XML::Error) do
       parser.parse
     end
     assert(!parser.context.well_formed?)
@@ -92,34 +92,34 @@ class TestParserContext < Minitest::Test
 
   def test_version_info
     file = File.expand_path(File.join(File.dirname(__FILE__), 'model/bands.utf-8.xml'))
-    parser = XML::Parser.file(file)
+    parser = LibXML::XML::Parser.file(file)
     assert_nil(parser.context.version)
     parser.parse
     assert_equal("1.0", parser.context.version)
   end
 
   def test_depth
-    context = XML::Parser::Context.new
-    assert_instance_of(Fixnum, context.depth)
+    context = LibXML::XML::Parser::Context.new
+    assert_instance_of(Integer, context.depth)
   end
 
   def test_disable_sax
-    context = XML::Parser::Context.new
+    context = LibXML::XML::Parser::Context.new
     assert(!context.disable_sax?)
   end
 
   def test_docbook
-    context = XML::Parser::Context.new
+    context = LibXML::XML::Parser::Context.new
     assert(!context.docbook?)
   end
 
   def test_html
-    context = XML::Parser::Context.new
+    context = LibXML::XML::Parser::Context.new
     assert(!context.html?)
   end
 
   def test_keep_blanks
-    context = XML::Parser::Context.new
+    context = LibXML::XML::Parser::Context.new
     if context.keep_blanks?
       assert_instance_of(TrueClass, context.keep_blanks?)
     else
@@ -127,18 +127,12 @@ class TestParserContext < Minitest::Test
     end
   end
 
-  if ENV['NOTWORKING']
-    def test_num_chars
-      assert_equal(17, context.num_chars)
-    end
-  end
-
   def test_replace_entities
-    context = XML::Parser::Context.new
+    context = LibXML::XML::Parser::Context.new
     assert(!context.replace_entities?)
 
-#    context.options = 1
- #   assert(context.replace_entities?)
+    context.options = LibXML::XML::Parser::Options::NOENT
+    assert(context.replace_entities?)
 
     context.options = 0
     assert(!context.replace_entities?)
@@ -148,52 +142,52 @@ class TestParserContext < Minitest::Test
   end
 
   def test_space_depth
-    context = XML::Parser::Context.new
+    context = LibXML::XML::Parser::Context.new
     assert_equal(1, context.space_depth)
   end
 
   def test_subset_external
-    context = XML::Parser::Context.new
+    context = LibXML::XML::Parser::Context.new
     assert(!context.subset_external?)
   end
 
   def test_data_directory_get
-    context = XML::Parser::Context.new
+    context = LibXML::XML::Parser::Context.new
     assert_nil(context.data_directory)
   end
 
   def test_parse_error
-    xp = XML::Parser.string('<foo><bar/></foz>')
+    xp = LibXML::XML::Parser.string('<foo><bar/></foz>')
 
-    assert_raises(XML::Error) do
+    assert_raises(LibXML::XML::Error) do
       xp.parse
     end
 
     # Now check context
     context = xp.context
-    assert_equal(nil, context.data_directory)
+    assert_nil(context.data_directory)
     assert_equal(0, context.depth)
     assert_equal(true, context.disable_sax?)
     assert_equal(false, context.docbook?)
-    assert_equal(XML::Encoding::NONE, context.encoding)
+    assert_equal(LibXML::XML::Encoding::NONE, context.encoding)
     assert_equal(76, context.errno)
     assert_equal(false, context.html?)
     assert_equal(5, context.io_max_num_streams)
     assert_equal(1, context.io_num_streams)
     assert_equal(true, context.keep_blanks?)
     assert_equal(1, context.io_num_streams)
-    assert_equal(nil, context.name_node)
+    assert_nil(context.name_node)
     assert_equal(0, context.name_depth)
     assert_equal(10, context.name_depth_max)
-    assert_equal(17, context.num_chars)
+    assert([0, 17].include?(context.num_chars))
     assert_equal(false, context.replace_entities?)
     assert_equal(1, context.space_depth)
     assert_equal(10, context.space_depth_max)
     assert_equal(false, context.subset_external?)
-    assert_equal(nil, context.subset_external_system_id)
-    assert_equal(nil, context.subset_external_uri)
+    assert_nil(context.subset_external_system_id)
+    assert_nil(context.subset_external_uri)
     assert_equal(false, context.subset_internal?)
-    assert_equal(nil, context.subset_internal_name)
+    assert_nil(context.subset_internal_name)
     assert_equal(false, context.stats?)
     assert_equal(true, context.standalone?)
     assert_equal(false, context.valid)
@@ -201,4 +195,4 @@ class TestParserContext < Minitest::Test
     assert_equal('1.0', context.version)
     assert_equal(false, context.well_formed?)
   end
-end
+end

data/test/{tc_properties.rb → test_properties.rb}

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 
-require './test_helper'
+require_relative './test_helper'
 
 
 # attributes is deprecated - use attributes instead.
@@ -8,7 +8,7 @@ require './test_helper'
 
 class Testattributes < Minitest::Test
   def setup()
-    xp = XML::Parser.string('<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>')
+    xp = LibXML::XML::Parser.string('<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>')
     @doc = xp.parse
   end
 
@@ -19,20 +19,20 @@ class Testattributes < Minitest::Test
   def test_traversal
     attributes = @doc.root.attributes
     
-    assert_instance_of(XML::Attributes, attributes)
+    assert_instance_of(LibXML::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_instance_of(LibXML::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_instance_of(LibXML::XML::Attributes, attributes)
     assert_equal(0, attributes.length)
   end
 end