libxml-ruby 2.9.0-x64-mingw32 → 3.0.0-x64-mingw32

data/test/model/soap.xml

@@ -1,27 +1,27 @@
-<?xml version="1.0" encoding="utf-8"?>
-<soap:Envelope
-      xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
-      xmlns:xsd="http://www.w3.org/2001/XMLSchema"
-      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-      soap:encodingStyle="http://www.w3.org/2001/12/soap-encoding">
-  <soap:Body>
-    <getManufacturerNamesResponse name="widgestRus" xmlns="http://services.somewhere.com">
-      <IDAndNameList xmlns="http://services.somewhere.com">
-        <ns1:IdAndName xmlns:ns1="http://domain.somewhere.com">
-          <id xmlns="http://domain.somewhere.com">1</id>
-          <name xmlns="http://domain.somewhere.com">man1</name>
-
-        </ns1:IdAndName>
-        <ns1:IdAndName xmlns:ns1="http://domain.somewhere.com">
-          <id xmlns="http://domain.somewhere.com">2</id>
-          <name xmlns="http://domain.somewhere.com">man2</name>
-
-        </ns1:IdAndName>
-        <ns1:IdAndName xmlns:ns1="http://domain.somewhere.com">
-          <id xmlns="http://domain.somewhere.com">3</id>
-          <name xmlns="http://domain.somewhere.com">man3</name>
-        </ns1:IdAndName>
-      </IDAndNameList>
-    </getManufacturerNamesResponse>
-  </soap:Body>
-</soap:Envelope>
+<?xml version="1.0" encoding="utf-8"?>
+<soap:Envelope
+      xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
+      xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+      soap:encodingStyle="http://www.w3.org/2001/12/soap-encoding">
+  <soap:Body>
+    <getManufacturerNamesResponse name="widgestRus" xmlns="http://services.somewhere.com">
+      <IDAndNameList xmlns="http://services.somewhere.com">
+        <ns1:IdAndName xmlns:ns1="http://domain.somewhere.com">
+          <id xmlns="http://domain.somewhere.com">1</id>
+          <name xmlns="http://domain.somewhere.com">man1</name>
+
+        </ns1:IdAndName>
+        <ns1:IdAndName xmlns:ns1="http://domain.somewhere.com">
+          <id xmlns="http://domain.somewhere.com">2</id>
+          <name xmlns="http://domain.somewhere.com">man2</name>
+
+        </ns1:IdAndName>
+        <ns1:IdAndName xmlns:ns1="http://domain.somewhere.com">
+          <id xmlns="http://domain.somewhere.com">3</id>
+          <name xmlns="http://domain.somewhere.com">man3</name>
+        </ns1:IdAndName>
+      </IDAndNameList>
+    </getManufacturerNamesResponse>
+  </soap:Body>
+</soap:Envelope>

data/test/model/xinclude.xml

@@ -1,5 +1,5 @@
-<?xml version="1.0"?>
-<document xmlns:xi="http://www.w3.org/2001/XInclude">
-  <p>This libxml2 binding has the following project information:
-   <code><xi:include href="rubynet_project" parse="text"/></code></p>
+<?xml version="1.0"?>
+<document xmlns:xi="http://www.w3.org/2001/XInclude">
+  <p>This libxml2 binding has the following project information:
+   <code><xi:include href="rubynet_project" parse="text"/></code></p>
 </document>

data/test/tc_attributes.rb

@@ -74,12 +74,6 @@ class AttributesTest < Minitest::Test
     assert_nil(attr)
   end
 
-  def test_property
-    attr = city_member.property('name')
-    assert_instance_of(String, attr)
-    assert_equal('Cambridge', attr)
-  end
-
   def test_get_values
     assert_equal('Cambridge', city_member[:name])
     assert_equal('http://www.foo.net/cgi-bin/wfs?FeatureID=C10239', city_member[:href])

data/test/tc_error.rb

@@ -4,133 +4,133 @@ require './test_helper'
 require 'stringio'
 
 class TestError < Minitest::Test
-  def test_error_codes
-    assert_equal(4, XML::Error::DTD)
-    assert_equal(4, XML::Error.const_get('DTD'))
-
-    assert_equal(4, XML::Error::DOCUMENT_EMPTY)
-    assert_equal(4, XML::Error.const_get('DOCUMENT_EMPTY'))
-  end
-
-  def test_invalid_handler
-    assert_raises(RuntimeError) do
-      XML::Error.set_handler
-    end
-  end
-
-  def test_handler
-    exception = nil
-    XML::Error.set_handler do |error|
-      exception = error
-    end
-
-    # Raise the error
-    error = assert_raises(XML::Error) do
-      XML::Reader.string('<foo').read
-    end
-    assert_equal(exception, error)
-
-    # Check the handler worked
-    refute_nil(exception)
-    assert_kind_of(XML::Error, exception)
-    assert_equal("Fatal error: Couldn't find end of Start Tag foo at :1.", exception.message)
-    assert_equal(XML::Error::PARSER, exception.domain)
-    assert_equal(XML::Error::GT_REQUIRED, exception.code)
-    assert_equal(XML::Error::FATAL, exception.level)
-    assert_nil(exception.file)
-    assert_equal(1, exception.line)
-    assert_equal('foo', exception.str1)
-    assert_nil(exception.str2)
-    assert_nil(exception.str3)
-    assert_equal(0, exception.int1)
-    assert_equal(5, exception.int2)
-    assert_nil(exception.node)
-  end
-
-  def test_reset_handler
-    exception = nil
-    XML::Error.set_handler do |error|
-      exception = error
-    end
-
-    XML::Error.reset_handler
-    XML::Reader.string('<foo')
-    assert_nil(exception)
-  end
-
-  def test_get_handler
-    assert_respond_to(XML::Error, :get_handler)
-    assert_equal(0, XML::Error.method(:get_handler).arity)
-
-    saved_handler = XML::Error.get_handler
-    XML::Error.set_handler{ puts "New handler" }
-    refute_equal(XML::Error.get_handler, saved_handler)
-
-    XML::Error.set_handler(&saved_handler)
-    assert_equal(XML::Error.get_handler, saved_handler)
-  end
-
-  def test_verbose_handler
-    XML::Error.set_handler(&XML::Error::VERBOSE_HANDLER)
-    output = StringIO.new
-    original_stderr = Object::STDERR
-
-    Object.const_set(:STDERR, output)
-    begin
-      assert_raises(XML::Error) do
-        XML::Parser.string('<foo><bar/></foz>').parse
-      end
-    ensure
-      Object.const_set(:STDERR, original_stderr)
-    end
-    assert_equal("Fatal error: Opening and ending tag mismatch: foo line 1 and foz at :1.\n", output.string)
-  end
-
-  def test_no_hanlder
-    XML::Error.reset_handler
-    output = StringIO.new
-    original_stderr = Object::STDERR
-
-    Object.const_set(:STDERR, output)
-    begin
-      assert_raises(XML::Error) do
-        XML::Parser.string('<foo><bar/></foz>').parse
-      end
-    ensure
-      Object.const_set(:STDERR, original_stderr)
-    end
-    assert_equal('', output.string)
-  end
-
-  def test_parse_error
-    exception = assert_raises(XML::Error) do
-      XML::Parser.string('<foo><bar/></foz>').parse
-    end
-
-    assert_instance_of(XML::Error, exception)
-    assert_equal("Fatal error: Opening and ending tag mismatch: foo line 1 and foz at :1.", exception.message)
-    assert_equal(XML::Error::PARSER, exception.domain)
-    assert_equal(XML::Error::TAG_NAME_MISMATCH, exception.code)
-    assert_equal(XML::Error::FATAL, exception.level)
-    assert_nil(exception.file)
-    assert_equal(1, exception.line)
-  end
-
-  def test_xpath_error
-    doc = XML::Document.file(File.join(File.dirname(__FILE__), 'model/soap.xml'))
-
-    exception = assert_raises(XML::Error) do
-      doc.find('/foo[bar=test')
-    end
-
-    assert_instance_of(XML::Error, exception)
-    assert_equal("Error: Invalid predicate.", exception.message)
-    assert_equal(XML::Error::XPATH, exception.domain)
-    assert_equal(XML::Error::XPATH_INVALID_PREDICATE_ERROR, exception.code)
-    assert_equal(XML::Error::ERROR, exception.level)
-    assert_nil(exception.file)
-    assert_nil(nil)
-  end
+  # def test_error_codes
+  #   assert_equal(4, XML::Error::DTD)
+  #   assert_equal(4, XML::Error.const_get('DTD'))
+  #
+  #   assert_equal(4, XML::Error::DOCUMENT_EMPTY)
+  #   assert_equal(4, XML::Error.const_get('DOCUMENT_EMPTY'))
+  # end
+  #
+  # def test_invalid_handler
+  #   assert_raises(RuntimeError) do
+  #     XML::Error.set_handler
+  #   end
+  # end
+  #
+  # def test_handler
+  #   exception = nil
+  #   XML::Error.set_handler do |error|
+  #     exception = error
+  #   end
+  #
+  #   # Raise the error
+  #   error = assert_raises(XML::Error) do
+  #     XML::Reader.string('<foo').read
+  #   end
+  #   assert_equal(exception, error)
+  #
+  #   # Check the handler worked
+  #   refute_nil(exception)
+  #   assert_kind_of(XML::Error, exception)
+  #   assert_equal("Fatal error: Couldn't find end of Start Tag foo at :1.", exception.message)
+  #   assert_equal(XML::Error::PARSER, exception.domain)
+  #   assert_equal(XML::Error::GT_REQUIRED, exception.code)
+  #   assert_equal(XML::Error::FATAL, exception.level)
+  #   assert_nil(exception.file)
+  #   assert_equal(1, exception.line)
+  #   assert_equal('foo', exception.str1)
+  #   assert_nil(exception.str2)
+  #   assert_nil(exception.str3)
+  #   assert_equal(0, exception.int1)
+  #   assert_equal(5, exception.int2)
+  #   assert_nil(exception.node)
+  # end
+  #
+  # def test_reset_handler
+  #   exception = nil
+  #   XML::Error.set_handler do |error|
+  #     exception = error
+  #   end
+  #
+  #   XML::Error.reset_handler
+  #   XML::Reader.string('<foo')
+  #   assert_nil(exception)
+  # end
+  #
+  # def test_get_handler
+  #   assert_respond_to(XML::Error, :get_handler)
+  #   assert_equal(0, XML::Error.method(:get_handler).arity)
+  #
+  #   saved_handler = XML::Error.get_handler
+  #   XML::Error.set_handler{ puts "New handler" }
+  #   refute_equal(XML::Error.get_handler, saved_handler)
+  #
+  #   XML::Error.set_handler(&saved_handler)
+  #   assert_equal(XML::Error.get_handler, saved_handler)
+  # end
+  #
+  # def test_verbose_handler
+  #   XML::Error.set_handler(&XML::Error::VERBOSE_HANDLER)
+  #   output = StringIO.new
+  #   original_stderr = Object::STDERR
+  #
+  #   Object.const_set(:STDERR, output)
+  #   begin
+  #     assert_raises(XML::Error) do
+  #       XML::Parser.string('<foo><bar/></foz>').parse
+  #     end
+  #   ensure
+  #     Object.const_set(:STDERR, original_stderr)
+  #   end
+  #   assert_equal("Fatal error: Opening and ending tag mismatch: foo line 1 and foz at :1.\n", output.string)
+  # end
+  #
+  # def test_no_hanlder
+  #   XML::Error.reset_handler
+  #   output = StringIO.new
+  #   original_stderr = Object::STDERR
+  #
+  #   Object.const_set(:STDERR, output)
+  #   begin
+  #     assert_raises(XML::Error) do
+  #       XML::Parser.string('<foo><bar/></foz>').parse
+  #     end
+  #   ensure
+  #     Object.const_set(:STDERR, original_stderr)
+  #   end
+  #   assert_equal('', output.string)
+  # end
+  #
+  # def test_parse_error
+  #   exception = assert_raises(XML::Error) do
+  #     XML::Parser.string('<foo><bar/></foz>').parse
+  #   end
+  #
+  #   assert_instance_of(XML::Error, exception)
+  #   assert_equal("Fatal error: Opening and ending tag mismatch: foo line 1 and foz at :1.", exception.message)
+  #   assert_equal(XML::Error::PARSER, exception.domain)
+  #   assert_equal(XML::Error::TAG_NAME_MISMATCH, exception.code)
+  #   assert_equal(XML::Error::FATAL, exception.level)
+  #   assert_nil(exception.file)
+  #   assert_equal(1, exception.line)
+  # end
+  #
+  # def test_xpath_error
+  #   doc = XML::Document.file(File.join(File.dirname(__FILE__), 'model/soap.xml'))
+  #
+  #   exception = assert_raises(XML::Error) do
+  #     doc.find('/foo[bar=test')
+  #   end
+  #
+  #   assert_instance_of(XML::Error, exception)
+  #   assert_equal("Error: Invalid predicate.", exception.message)
+  #   assert_equal(XML::Error::XPATH, exception.domain)
+  #   assert_equal(XML::Error::XPATH_INVALID_PREDICATE_ERROR, exception.code)
+  #   assert_equal(XML::Error::ERROR, exception.level)
+  #   assert_nil(exception.file)
+  #   assert_nil(nil)
+  # end
 
   def test_double_parse
     XML::Parser.register_error_handler(lambda {|msg| nil })
@@ -145,35 +145,34 @@ class TestError < Minitest::Test
     assert_equal(" LibXML::XML::Error.", error.to_s)
   end
 
-  def test_libxml_parser_empty_string
-    xp = XML::Parser.new
-
-    error = assert_raises(TypeError) do
-      xp.string = nil
-    end
-    assert_equal('wrong argument type nil (expected String)', error.to_s)
-
-    error = assert_raises(ArgumentError) do
-      xp.string = ''
-    end
-    assert_equal('Must specify a string with one or more characters', error.to_s)
-  end
-
-  def test_error_domain_to_s
-    exception = assert_raises(XML::Error) do
-      XML::Parser.string('<foo href="http://example.org/cgi?k1=v1&k2=v2"></foo>').parse
-    end
-
-    assert_equal(XML::Error::PARSER, exception.domain)
-    assert_equal("PARSER",exception.domain_to_s)
-  end
-
-  def test_error_code_to_s
-    exception = assert_raises(XML::Error) do
-      XML::Parser.string('<foo href="http://example.org/cgi?k1=v1&k2=v2"></foo>').parse
-    end
-    assert_equal(XML::Error::ENTITYREF_SEMICOL_MISSING, exception.code)
-    assert_equal("ENTITYREF_SEMICOL_MISSING",exception.code_to_s)
-  end
-
+  # def test_libxml_parser_empty_string
+  #   xp = XML::Parser.new
+  #
+  #   error = assert_raises(TypeError) do
+  #     xp.string = nil
+  #   end
+  #   assert_equal('wrong argument type nil (expected String)', error.to_s)
+  #
+  #   error = assert_raises(ArgumentError) do
+  #     xp.string = ''
+  #   end
+  #   assert_equal('Must specify a string with one or more characters', error.to_s)
+  # end
+  #
+  # def test_error_domain_to_s
+  #   exception = assert_raises(XML::Error) do
+  #     XML::Parser.string('<foo href="http://example.org/cgi?k1=v1&k2=v2"></foo>').parse
+  #   end
+  #
+  #   assert_equal(XML::Error::PARSER, exception.domain)
+  #   assert_equal("PARSER",exception.domain_to_s)
+  # end
+  #
+  # def test_error_code_to_s
+  #   exception = assert_raises(XML::Error) do
+  #     XML::Parser.string('<foo href="http://example.org/cgi?k1=v1&k2=v2"></foo>').parse
+  #   end
+  #   assert_equal(XML::Error::ENTITYREF_SEMICOL_MISSING, exception.code)
+  #   assert_equal("ENTITYREF_SEMICOL_MISSING",exception.code_to_s)
+  # end
 end

data/test/tc_node.rb

@@ -71,7 +71,7 @@ class TestNode < Minitest::Test
       assert_instance_of(XML::Document, n.doc) if n.document?
     end
   end
-  
+
   def test_name
     node = @doc.root.children.last
     assert_equal("iron_maiden", node.name)
@@ -84,23 +84,39 @@ class TestNode < Minitest::Test
     end
   end
 
-  def test_equality
+   def test_equality
     node_a = @doc.find_first('*[@country]')
     node_b = @doc.root.child
 
+    # On the ruby side these are different objects
+    refute(node_a.equal?(node_b))
+
+    # But they are the same underlying libxml node so specify they are equal
     assert(node_a == node_b)
     assert(node_a.eql?(node_b))
-    assert(node_a.equal?(node_b))
 
     file = File.join(File.dirname(__FILE__), @file_name)
     doc2 = XML::Document.file(file)
 
     node_a2 = doc2.find_first('*[@country]')
 
+    refute(node_a == node_a2)
+    refute(node_a.eql?(node_a2))
     assert_equal(node_a.to_s, node_a2.to_s)
-    assert_equal(node_a, node_a2)
-    assert(node_a.eql?(node_a2))
-    assert(!node_a.equal?(node_a2))
+    refute(node_a.equal?(node_a2))
+  end
+
+  def test_equality_2
+    parent = XML::Node.new('parent')
+    child = XML::Node.new('child')
+    parent << child
+
+    node_a = child.parent
+    node_b = child.parent
+    # In this case the nodes are equal - the parent being the root
+    assert(node_a.equal?(node_b))
+    assert(node_a == node_b)
+    assert(node_a.eql?(node_b))
   end
 
   def test_equality_nil
@@ -127,14 +143,14 @@ class TestNode < Minitest::Test
     assert_nil(doc.root.base_uri)
   end
 
-	# We use the same facility that libXSLT does here to disable output escaping.
-	# This lets you specify that the node's content should be rendered unaltered
-	# whenever it is being output.  This is useful for things like <script> and
-	# <style> nodes in HTML documents if you don't want to be forced to wrap them
-	# in CDATA nodes.  Or if you are sanitizing existing HTML documents and want
-	# to preserve the content of any of the text nodes.
-	#
-	def test_output_escaping
+  # We use the same facility that libXSLT does here to disable output escaping.
+  # This lets you specify that the node's content should be rendered unaltered
+  # whenever it is being output.  This is useful for things like <script> and
+  # <style> nodes in HTML documents if you don't want to be forced to wrap them
+  # in CDATA nodes.  Or if you are sanitizing existing HTML documents and want
+  # to preserve the content of any of the text nodes.
+  #
+  def test_output_escaping
 		text = '<bad-script>if (a &lt; b || b &gt; c) { return "text"; }<stop/>return "&gt;&gt;&gt;snip&lt;&lt;&lt;";</bad-script>'
     node = XML::Parser.string(text).parse.root
 		assert_equal text, node.to_s
@@ -153,8 +169,8 @@ class TestNode < Minitest::Test
 		assert_equal text, node.to_s
   end
 
-	# Just a sanity check for output escaping.
-	def test_output_escaping_sanity
+  # Just a sanity check for output escaping.
+  def test_output_escaping_sanity
 		text = '<bad-script>if (a &lt; b || b &gt; c) { return "text"; }<stop/>return "&gt;&gt;&gt;snip&lt;&lt;&lt;";</bad-script>'
     node = XML::Parser.string(text).parse.root
 		affected = node.find('//text()')
@@ -201,7 +217,7 @@ class TestNode < Minitest::Test
 
     node = doc.root
     assert(!node.empty?)
-    
+
     text_node = node.first
     assert(text_node.empty?)
   end