libxml-ruby 2.8.0 → 3.2.3

data/test/{tc_xinclude.rb → test_xinclude.rb}

@@ -1,12 +1,11 @@
 # encoding: UTF-8
 
-require './test_helper'
-require 'test/unit'
+require_relative './test_helper'
 
-class TestXInclude < Test::Unit::TestCase
+class TestXInclude < Minitest::Test
   def setup
-    @doc = XML::Document.file(File.join(File.dirname(__FILE__), 'model/xinclude.xml'))
-    assert_instance_of(XML::Document, @doc)
+    @doc = LibXML::XML::Document.file(File.join(File.dirname(__FILE__), 'model/xinclude.xml'))
+    assert_instance_of(LibXML::XML::Document, @doc)
   end
 
   def teardown

data/test/test_xml.rb

@@ -0,0 +1,263 @@
+# encoding: UTF-8
+
+require_relative './test_helper'
+require 'stringio'
+
+class TestXml < Minitest::Test
+  # -----  Constants  ------
+  def test_lib_versions
+    assert(LibXML::XML.check_lib_versions)
+  end
+
+  def test_debug_entities
+    original = LibXML::XML.debug_entities
+
+    LibXML::XML.debug_entities = false
+    refute(LibXML::XML.debug_entities)
+
+    LibXML::XML.debug_entities = true
+    assert(LibXML::XML.debug_entities)
+
+    LibXML::XML.debug_entities = false
+    refute(LibXML::XML.debug_entities)
+
+    LibXML::XML.debug_entities = original
+  end
+
+  def test_default_compression
+    return unless LibXML::XML.default_compression
+
+    original = LibXML::XML.default_compression
+
+    0.upto(9) do |i|
+      LibXML::XML.default_compression = i
+      assert_equal(i, LibXML::XML.default_compression)
+    end
+
+    9.downto(0) do |i|
+      assert_equal(i, LibXML::XML.default_compression = i)
+      assert_equal(i, LibXML::XML.default_compression)
+    end
+
+    0.downto(-10) do |i|
+      assert_equal(i, LibXML::XML.default_compression = i)
+      assert_equal(0, LibXML::XML.default_compression)
+    end
+
+    10.upto(20) do |i|
+      assert_equal(i, LibXML::XML.default_compression = i)
+      assert_equal(9, LibXML::XML.default_compression)
+    end
+
+    LibXML::XML.default_compression = original
+  end
+
+  def test_default_keep_blanks
+    original = LibXML::XML.default_keep_blanks
+
+    LibXML::XML.default_keep_blanks = false
+    refute(LibXML::XML.default_keep_blanks)
+    assert_equal(LibXML::XML::Parser::Options::NOBLANKS, LibXML::XML.default_options)
+
+    LibXML::XML.default_keep_blanks = true
+    assert(LibXML::XML.default_keep_blanks)
+    assert_equal(0, LibXML::XML.default_options)
+
+    LibXML::XML.default_keep_blanks = original
+  end
+
+  def test_default_line_numbers
+    original = LibXML::XML.default_line_numbers
+
+    LibXML::XML.default_line_numbers = false
+    refute(LibXML::XML.default_line_numbers)
+
+    LibXML::XML.default_line_numbers = true
+    assert(LibXML::XML.default_line_numbers)
+
+    LibXML::XML.default_line_numbers = false
+    refute(LibXML::XML.default_line_numbers)
+
+    LibXML::XML.default_line_numbers = original
+  end
+
+  def test_default_substitute_entities
+    original = LibXML::XML.default_substitute_entities
+
+    LibXML::XML.default_substitute_entities = false
+    refute(LibXML::XML.default_substitute_entities)
+    assert_equal(0, LibXML::XML.default_options)
+
+    LibXML::XML.default_substitute_entities = true
+    assert(LibXML::XML.default_substitute_entities)
+    assert_equal(LibXML::XML::Parser::Options::NOENT, LibXML::XML.default_options)
+
+    LibXML::XML.default_substitute_entities = false
+    refute(LibXML::XML.default_substitute_entities)
+
+    LibXML::XML.default_substitute_entities = original
+  end
+
+  def test_default_tree_indent_string
+    original = LibXML::XML.default_tree_indent_string
+
+    s = LibXML::XML.default_tree_indent_string
+    assert_instance_of(String, s)
+    assert_equal('  ', s)
+    LibXML::XML.default_tree_indent_string = 'uga'
+    s = LibXML::XML.default_tree_indent_string
+    assert_instance_of(String, s)
+    assert_equal('uga', s)
+    LibXML::XML.default_tree_indent_string = '  '
+    s = LibXML::XML.default_tree_indent_string
+    assert_instance_of(String, s)
+    assert_equal('  ', s)
+
+    LibXML::XML.default_tree_indent_string = original
+  end
+
+  def test_default_validity_checking
+    original = LibXML::XML.default_validity_checking
+
+    LibXML::XML.default_validity_checking = false
+    refute(LibXML::XML.default_validity_checking)
+    assert_equal(0, LibXML::XML.default_options)
+
+    LibXML::XML.default_validity_checking = true
+    assert(LibXML::XML.default_validity_checking)
+    assert_equal(LibXML::XML::Parser::Options::DTDVALID, LibXML::XML.default_options)
+
+    LibXML::XML.default_validity_checking = false
+    refute(LibXML::XML.default_validity_checking)
+
+    LibXML::XML.default_validity_checking = original
+  end
+
+  def test_default_warnings
+    original = LibXML::XML.default_warnings
+
+    LibXML::XML.default_warnings = false
+    refute(LibXML::XML.default_warnings)
+    assert_equal(LibXML::XML::Parser::Options::NOWARNING, LibXML::XML.default_options)
+
+    LibXML::XML.default_warnings = true
+    assert(LibXML::XML.default_warnings)
+    assert_equal(0, LibXML::XML.default_options)
+
+    LibXML::XML.default_warnings = false
+    refute(LibXML::XML.default_warnings)
+
+    LibXML::XML.default_warnings = original
+  end
+
+  def test_enabled_automata
+    assert(LibXML::XML.enabled_automata?)
+  end
+
+  def test_enabled_c14n
+    assert(LibXML::XML.enabled_c14n?)
+  end
+
+  def test_enabled_catalog
+    assert(LibXML::XML.enabled_catalog?)
+  end
+
+  def test_enabled_debug
+    assert(LibXML::XML.enabled_debug?)
+  end
+
+  def test_enabled_docbook
+    assert(LibXML::XML.enabled_docbook?)
+  end
+
+  def test_enabled_ftp
+    assert(LibXML::XML.enabled_ftp?)
+  end
+
+  def test_enabled_http
+    assert(LibXML::XML.enabled_http?)
+  end
+
+  def test_enabled_html
+    assert(LibXML::XML.enabled_html?)
+  end
+
+  def test_enabled_iconv
+    iconv_enabled = RUBY_PLATFORM !~ /darwin/
+    assert_equal(iconv_enabled, LibXML::XML.enabled_iconv?)
+  end
+
+  def test_enabled_memory_debug
+    assert_equal(false, LibXML::XML.enabled_memory_debug?)
+  end
+
+  def test_enabled_regexp
+    assert(LibXML::XML.enabled_regexp?)
+  end
+
+  def test_enabled_schemas
+    assert(LibXML::XML.enabled_schemas?)
+  end
+
+  def test_enabled_thread
+    assert(LibXML::XML.enabled_thread?)
+  end
+
+  def test_enabled_unicode
+    assert(LibXML::XML.enabled_unicode?)
+  end
+
+  def test_enabled_xinclude
+    assert(LibXML::XML.enabled_xinclude?)
+  end
+
+  def test_enabled_xpath
+    assert(LibXML::XML.enabled_xpath?)
+  end
+
+  def test_enabled_xpointer
+    assert(LibXML::XML.enabled_xpointer?)
+  end
+
+  def test_enabled_zlib
+    assert(LibXML::XML.enabled_zlib?.is_a?(TrueClass) || LibXML::XML.enabled_zlib?.is_a?(FalseClass))
+  end
+
+  def test_intent_tree_output
+    assert(TrueClass, LibXML::XML.indent_tree_output)
+
+    LibXML::XML.indent_tree_output = false
+    assert(FalseClass, LibXML::XML.indent_tree_output)
+
+    LibXML::XML.indent_tree_output = true
+    assert(TrueClass, LibXML::XML.indent_tree_output)
+  end
+
+  def test_version
+    assert_instance_of(String, LibXML::XML::VERSION)
+  end
+
+  def test_vernum
+    assert_instance_of(Integer, LibXML::XML::VERNUM)
+  end
+
+  def test_libxml_parser_features
+    assert_instance_of(Array, LibXML::XML.features)
+  end
+
+  def test_default_options
+    assert_equal(0, LibXML::XML.default_options)
+  end
+
+  def test_default_save_no_empty_tags
+    original = LibXML::XML.default_save_no_empty_tags
+
+    LibXML::XML.default_save_no_empty_tags = false
+    refute(LibXML::XML.default_save_no_empty_tags)
+
+    LibXML::XML.default_save_no_empty_tags = true
+    assert(LibXML::XML.default_save_no_empty_tags)
+
+    LibXML::XML.default_save_no_empty_tags = original
+  end
+end

data/test/{tc_xpath.rb → test_xpath.rb}

@@ -1,12 +1,11 @@
 # encoding: UTF-8
 
-require './test_helper'
+require_relative './test_helper'
 require 'tempfile'
-require 'test/unit'
 
-class TestXPath < Test::Unit::TestCase
+class TestXPath < Minitest::Test
   def setup
-    @doc = XML::Document.file(File.join(File.dirname(__FILE__), 'model/soap.xml'))
+    @doc = LibXML::XML::Document.file(File.join(File.dirname(__FILE__), 'model/soap.xml'))
   end
   
   def teardown
@@ -15,14 +14,14 @@ class TestXPath < Test::Unit::TestCase
   
   def test_doc_find
     nodes = @doc.find('/soap:Envelope')
-    assert_instance_of(XML::XPath::Object, nodes)
+    assert_instance_of(LibXML::XML::XPath::Object, nodes)
     assert_equal(1, nodes.length)
-    assert_equal(nodes.xpath_type, XML::XPath::NODESET)
+    assert_equal(nodes.xpath_type, LibXML::XML::XPath::NODESET)
   end
 
   def test_doc_find_first
     node = @doc.find_first('/soap:Envelope/soap:Body')
-    assert_instance_of(XML::Node, node)
+    assert_instance_of(LibXML::XML::Node, node)
   end
 
   def test_ns
@@ -34,7 +33,7 @@ class TestXPath < Test::Unit::TestCase
     _stress = GC.stress
     GC.stress = true
 
-    doc = XML::Document.string('<foo xmlns="http://bar.com" />')
+    doc = LibXML::XML::Document.string('<foo xmlns="http://bar.com" />')
     node = doc.root
     # This line segfaults on prior versions of libxml-ruby
     node.find("namespace::*")
@@ -90,7 +89,7 @@ class TestXPath < Test::Unit::TestCase
 
   def test_default_ns5
     # Find all nodes with http://services.somewhere.com namespace
-    XML::Namespace.new(@doc.root, 'ns', 'http://services.somewhere.com')
+    LibXML::XML::Namespace.new(@doc.root, 'ns', 'http://services.somewhere.com')
     nodes = @doc.find('//ns:*')
     assert_equal(2, nodes.length)
     assert_equal('getManufacturerNamesResponse', nodes[0].name)
@@ -106,20 +105,20 @@ class TestXPath < Test::Unit::TestCase
   end
 
   def test_register_default_ns
-    doc = XML::Document.file(File.join(File.dirname(__FILE__), 'model/atom.xml'))
+    doc = LibXML::XML::Document.file(File.join(File.dirname(__FILE__), 'model/atom.xml'))
 
     # No namespace has been yet defined
-    assert_raise(XML::Error) do
-      node = doc.find("atom:title")
+    assert_raises(LibXML::XML::Error) do
+      doc.find("atom:title")
     end
 
     node = doc.find('atom:title', 'atom:http://www.w3.org/2005/Atom')
-    assert_not_nil(node)
+    refute_nil(node)
 
     # Register namespace
     doc.root.namespaces.default_prefix = 'atom'
     node = doc.find("atom:title")
-    assert_not_nil(node)
+    refute_nil(node)
   end
 
   def test_node_find
@@ -129,7 +128,7 @@ class TestXPath < Test::Unit::TestCase
     # Since we are searching on the node, don't have to register namespace
     nodes = node.find('ns1:name')
     assert_equal(1, nodes.length)
-		assert_equal(nodes.first.object_id, nodes.last.object_id, 'First and last should be the same')
+		refute_equal(nodes.first.object_id, nodes.last.object_id)
     assert_equal('name', nodes.first.name)
     assert_equal('man1', nodes.first.content)
   end
@@ -144,8 +143,8 @@ class TestXPath < Test::Unit::TestCase
   end
 
   def test_node_no_doc
-    node = XML::Node.new('header', 'some content')
-    assert_raise(TypeError) do
+    node = LibXML::XML::Node.new('header', 'some content')
+    assert_raises(TypeError) do
       node = node.find_first('/header')
     end
   end
@@ -158,63 +157,63 @@ class TestXPath < Test::Unit::TestCase
     # to the document's nodes. A segmentation fault then happens.
 
     1000.times do
-      doc = XML::Document.new('1.0')
-      doc.root = XML::Node.new("header")
+      doc = LibXML::XML::Document.new('1.0')
+      doc.root = LibXML::XML::Node.new("header")
 
       1000.times do
-        doc.root << XML::Node.new("footer")
+        doc.root << LibXML::XML::Node.new("footer")
       end
 
-      nodes = doc.find('/header/footer')
+      doc.find('/header/footer')
     end
   end
 
   # Test that document doesn't get freed before nodes
   def test_xpath_free
-    doc = XML::Document.file(File.join(File.dirname(__FILE__), 'model/soap.xml'))
+    doc = LibXML::XML::Document.file(File.join(File.dirname(__FILE__), 'model/soap.xml'))
     nodes = doc.find('//*')
     GC.start
     assert_equal('Envelope', nodes.first.name)
   end
 
   def test_xpath_namespace_nodes
-    doc = XML::Document.string('<feed xmlns="http://www.w3.org/2005/Atom" xmlns:xhtml="http://www.w3.org/1999/xhtml"><entry/></feed>')
+    doc = LibXML::XML::Document.string('<feed xmlns="http://www.w3.org/2005/Atom" xmlns:xhtml="http://www.w3.org/1999/xhtml"><entry/></feed>')
     nodes = doc.find('//atom:entry|namespace::*', :atom => "http://www.w3.org/2005/Atom")
     assert_equal(4, nodes.length)
 
     node = nodes[0]
-    assert_equal(XML::Node::ELEMENT_NODE, node.node_type)
+    assert_equal(LibXML::XML::Node::ELEMENT_NODE, node.node_type)
 
     node = nodes[1]
-    assert_equal(XML::Node::NAMESPACE_DECL, node.node_type)
+    assert_equal(LibXML::XML::Node::NAMESPACE_DECL, node.node_type)
 
     node = nodes[2]
-    assert_equal(XML::Node::NAMESPACE_DECL, node.node_type)
+    assert_equal(LibXML::XML::Node::NAMESPACE_DECL, node.node_type)
 
     node = nodes[3]
-    assert_equal(XML::Node::NAMESPACE_DECL, node.node_type)
+    assert_equal(LibXML::XML::Node::NAMESPACE_DECL, node.node_type)
   end
 
 	# Test to make sure we don't get nil on empty results.
 	# This is also to test that we don't segfault due to our C code getting a NULL pointer
 	# and not handling it properly.
 	def test_xpath_empty_result
-    doc = XML::Document.string('<html><body><p>Welcome to XHTML land!</p></body></html>')
+    doc = LibXML::XML::Document.string('<html><body><p>Welcome to XHTML land!</p></body></html>')
 		nodes = doc.find("//object/param[translate(@name, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz') = 'wmode']")
-		assert_not_nil nodes
+		refute_nil nodes
 	end
 
   def test_invalid_expression
     xml = LibXML::XML::Document.string('<a></a>')
 
     # Using the expression twice used to cause a Segmentation Fault
-    error = assert_raise(XML::Error) do
+    error = assert_raises(LibXML::XML::Error) do
       xml.find('//a/')
     end
     assert_equal("Error: Invalid expression.", error.to_s)
 
     # Try again - this used to cause a Segmentation Fault
-    error = assert_raise(XML::Error) do
+    error = assert_raises(LibXML::XML::Error) do
       xml.find('//a/')
     end
     assert_equal("Error: Invalid expression.", error.to_s)
@@ -242,4 +241,4 @@ class TestXPath < Test::Unit::TestCase
     assert_equal(1, nodes.length)
     assert_equal(nodes[0].content, ' my comment ')
   end
-end
+end

data/test/{tc_xpath_context.rb → test_xpath_context.rb}

@@ -1,10 +1,9 @@
 # encoding: UTF-8
 
-require './test_helper'
+require_relative './test_helper'
 require "tempfile"
-require "test/unit"
 
-class TestXPathContext < Test::Unit::TestCase
+class TestXPathContext < Minitest::Test
   SOAP_PREFIX = 'soap'
   SOAP_URI = 'http://schemas.xmlsoap.org/soap/envelope/'
   
@@ -12,8 +11,8 @@ class TestXPathContext < Test::Unit::TestCase
   NS0_URI = 'http://services.somewhere.com'
   
   def setup
-    doc = XML::Document.file(File.join(File.dirname(__FILE__), 'model/soap.xml'))
-    @context = XML::XPath::Context.new(doc)
+    doc = LibXML::XML::Document.file(File.join(File.dirname(__FILE__), 'model/soap.xml'))
+    @context = LibXML::XML::XPath::Context.new(doc)
   end
   
   def teardown()
@@ -21,7 +20,7 @@ class TestXPathContext < Test::Unit::TestCase
   end
   
   def test_no_ns
-    error = assert_raise(LibXML::XML::Error) do
+    error = assert_raises(LibXML::XML::Error) do
       @context.find('/soap:Envelope')
     end
     assert_equal("Error: Undefined namespace prefix.", error.to_s)
@@ -80,9 +79,9 @@ class TestXPathContext < Test::Unit::TestCase
   end
 
   def test_require_doc
-    doc = XML::Document.file(File.join(File.dirname(__FILE__), 'model/soap.xml'))
-    error = assert_raise(TypeError) do
-      @context = XML::XPath::Context.new(doc.root)
+    doc = LibXML::XML::Document.file(File.join(File.dirname(__FILE__), 'model/soap.xml'))
+    error = assert_raises(TypeError) do
+      @context = LibXML::XML::XPath::Context.new(doc.root)
     end
     assert_equal("Supplied argument must be a document or node.", error.to_s)
   end

data/test/test_xpath_expression.rb

@@ -0,0 +1,37 @@
+# encoding: UTF-8
+
+require_relative './test_helper'
+
+
+class TestXPathExpression < Minitest::Test
+  def setup
+    xp = LibXML::XML::Parser.string('<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>')
+    @doc = xp.parse
+  end
+  
+  def teardown
+    @doc = nil
+  end
+
+  def test_nodes
+    expr = LibXML::XML::XPath::Expression.compile('/ruby_array/fixnum')
+    set = @doc.find(expr)
+    assert_instance_of(LibXML::XML::XPath::Object, set)
+    assert_equal(2, set.size)
+  end
+
+  def test_find_class
+    expr = LibXML::XML::XPath::Expression.new('/ruby_array/fixnum')
+    set = @doc.find(expr)
+    assert_instance_of(LibXML::XML::XPath::Object, set)
+    assert_equal(2, set.size)
+  end
+
+  def test_find_invalid
+    error = assert_raises(TypeError) do
+      @doc.find(999)
+    end
+    assert_equal('Argument should be an instance of a String or XPath::Expression',
+                 error.to_s)
+  end
+end

data/test/{tc_xpointer.rb → test_xpointer.rb}

@@ -1,15 +1,13 @@
 # encoding: UTF-8
+require_relative './test_helper'
 
-require './test_helper'
-require "test/unit"
-
-class TC_XML_XPointer < Test::Unit::TestCase
+class TC_XML_XPointer < Minitest::Test
   def setup()
-    xp = XML::Parser.string('<!DOCTYPE ra [<!ELEMENT ra (foo+)><!ATTLIST ra id ID #IMPLIED><!ELEMENT foo (#PCDATA)><!ATTLIST foo id ID #IMPLIED>]><ra id="start"><foo id="one">one</foo><foo id="two">two</foo><foo id="three">three</foo></ra>')
+    xp = LibXML::XML::Parser.string('<!DOCTYPE ra [<!ELEMENT ra (foo+)><!ATTLIST ra id ID #IMPLIED><!ELEMENT foo (#PCDATA)><!ATTLIST foo id ID #IMPLIED>]><ra id="start"><foo id="one">one</foo><foo id="two">two</foo><foo id="three">three</foo></ra>')
     @doc = xp.parse
-    assert_instance_of(XML::Document, @doc)
+    assert_instance_of(LibXML::XML::Document, @doc)
     @root = @doc.root
-    assert_instance_of(XML::Node, @root)
+    assert_instance_of(LibXML::XML::Node, @root)
   end
 
   def teardown()
@@ -20,20 +18,20 @@ class TC_XML_XPointer < Test::Unit::TestCase
 
   def test_libxml_xpointer_id
     xptr = @root.pointer('xpointer(id("two"))')
-    assert_instance_of(XML::XPath::Object, xptr)
+    assert_instance_of(LibXML::XML::XPath::Object, xptr)
     xptr.each do |node|
       # It seems from the spec that the pointer should
       # be the whole node, rather than just the ID attr.
       assert_equal('two', node.content)
-      assert_instance_of(XML::Node, node)
+      assert_instance_of(LibXML::XML::Node, node)
       assert_equal('two', node['id'])
     end
 
     # FIXME: Not sure at all about this kind of range
     if ENV['NOTWORKING']
       @xptr = @root.pointer('xpointer(id("two")) xpointer(id("three"))')
-      assert_instance_of(XML::XPath, @xptr)
-      assert_instance_of(XML::Node::Set, @xptr.set)
+      assert_instance_of(LibXML::XML::XPath, @xptr)
+      assert_instance_of(LibXML::XML::Node::Set, @xptr.set)
       assert_equal(2, @xptr.set.length)
       for n in @xptr.set
         assert_match(/two|three/, n.to_s)
@@ -47,13 +45,13 @@ class TC_XML_XPointer < Test::Unit::TestCase
       nstart = nend = nil
       @xptr = @root.pointer('xpointer(id("one"))').set
       @xptr.each{|n| nstart = n}
-      assert_instance_of(XML::Node, nstart)
+      assert_instance_of(LibXML::XML::Node, nstart)
       @xptr = @root.pointer('xpointer(id("three"))').set
       @xptr.each{|n| nend = n}
-      assert_instance_of(XML::Node, nend)
-      range = XML::XPointer.range(nstart, nend)
-      assert_instance_of(XML::XPath, range)
-      assert_instance_of(XML::Node::Set, range.set)
+      assert_instance_of(LibXML::XML::Node, nend)
+      range = LibXML::XML::XPointer.range(nstart, nend)
+      assert_instance_of(LibXML::XML::XPath, range)
+      assert_instance_of(LibXML::XML::Node::Set, range.set)
 
       for n in range.set
         assert_match(/one|two|three/, n.to_s)
@@ -64,9 +62,9 @@ class TC_XML_XPointer < Test::Unit::TestCase
 
 #  def test_libxml_xpointer_start_point()
 #    @xptr = @root.pointer('xpointer(start-point("one"))')
-#    assert_instance_of(XML::XPath, @xptr)
+#    assert_instance_of(LibXML::XML::XPath, @xptr)
 #    set = @xptr.set
-#    assert_instance_of(XML::Node::Set, set)
+#    assert_instance_of(LibXML::XML::Node::Set, set)
 #    for n in set
 #      assert_match(/one|two|three/, n.to_s)
 #    end