libxml-ruby 3.1.0-x64-mingw32 → 3.2.0-x64-mingw32

data/test/test_xinclude.rb

@@ -1,11 +1,11 @@
 # encoding: UTF-8
 
-require File.expand_path('../test_helper', __FILE__)
+require_relative './test_helper'
 
 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

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

@@ -1,11 +1,11 @@
 # encoding: UTF-8
 
-require File.expand_path('../test_helper', __FILE__)
+require_relative './test_helper'
 require 'tempfile'
 
 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
@@ -14,14 +14,14 @@ class TestXPath < Minitest::Test
   
   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
@@ -33,7 +33,7 @@ class TestXPath < Minitest::Test
     _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::*")
@@ -89,7 +89,7 @@ class TestXPath < Minitest::Test
 
   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)
@@ -105,10 +105,10 @@ class TestXPath < Minitest::Test
   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_raises(XML::Error) do
+    assert_raises(LibXML::XML::Error) do
       doc.find("atom:title")
     end
 
@@ -143,7 +143,7 @@ class TestXPath < Minitest::Test
   end
 
   def test_node_no_doc
-    node = XML::Node.new('header', 'some content')
+    node = LibXML::XML::Node.new('header', 'some content')
     assert_raises(TypeError) do
       node = node.find_first('/header')
     end
@@ -157,11 +157,11 @@ class TestXPath < Minitest::Test
     # 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
 
       doc.find('/header/footer')
@@ -170,35 +170,35 @@ class TestXPath < Minitest::Test
 
   # 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']")
 		refute_nil nodes
 	end
@@ -207,13 +207,13 @@ class TestXPath < Minitest::Test
     xml = LibXML::XML::Document.string('<a></a>')
 
     # Using the expression twice used to cause a Segmentation Fault
-    error = assert_raises(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_raises(XML::Error) do
+    error = assert_raises(LibXML::XML::Error) do
       xml.find('//a/')
     end
     assert_equal("Error: Invalid expression.", error.to_s)