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

data/test/test_html_parser_context.rb

@@ -1,23 +1,23 @@
 # encoding: UTF-8
 
-require File.expand_path('../test_helper', __FILE__)
+require_relative './test_helper'
 
 
 class TestHtmlParserContext < Minitest::Test
   def test_default_options
-    context = XML::HTMLParser::Context.new
+    context = LibXML::XML::HTMLParser::Context.new
     assert_equal(0, context.options)
   end
 
   def test_no_options
-    context = XML::HTMLParser::Context.new
+    context = LibXML::XML::HTMLParser::Context.new
     context.options = 0
     assert_equal(0, context.options)
   end
 
   def test_options
-    context = XML::HTMLParser::Context.new
-    context.options = XML::HTMLParser::Options::NOERROR
-    assert_equal(XML::HTMLParser::Options::NOERROR, context.options)
+    context = LibXML::XML::HTMLParser::Context.new
+    context.options = LibXML::XML::HTMLParser::Options::NOERROR
+    assert_equal(LibXML::XML::HTMLParser::Options::NOERROR, context.options)
   end
 end

data/test/test_namespace.rb

@@ -1,12 +1,12 @@
 # encoding: UTF-8
 
-require File.expand_path('../test_helper', __FILE__)
+require_relative './test_helper'
 
 
 class TestNS < Minitest::Test
   def setup
     file = File.join(File.dirname(__FILE__), 'model/soap.xml')
-    @doc = XML::Document.file(file)
+    @doc = LibXML::XML::Document.file(file)
   end
 
   def teardown
@@ -14,46 +14,46 @@ class TestNS < Minitest::Test
   end
 
   def test_create_ns
-    node = XML::Node.new('foo')
-    ns = XML::Namespace.new(node, 'my_namepace', 'http://www.mynamespace.com')
+    node = LibXML::XML::Node.new('foo')
+    ns = LibXML::XML::Namespace.new(node, 'my_namepace', 'http://www.mynamespace.com')
     assert_equal(ns.prefix, 'my_namepace')
     assert_equal(ns.href, 'http://www.mynamespace.com')
   end
 
   def test_create_default_ns
-    node = XML::Node.new('foo')
-    ns = XML::Namespace.new(node, nil, 'http://www.mynamespace.com')
+    node = LibXML::XML::Node.new('foo')
+    ns = LibXML::XML::Namespace.new(node, nil, 'http://www.mynamespace.com')
     assert_nil(ns.prefix)
     assert_equal(ns.href, 'http://www.mynamespace.com')
   end
 
   def test_create_unbound_ns
     error = assert_raises(TypeError) do
-      XML::Namespace.new(nil, 'my_namepace', 'http://www.mynamespace.com')
+      LibXML::XML::Namespace.new(nil, 'my_namepace', 'http://www.mynamespace.com')
     end
     assert_equal('wrong argument type nil (expected Data)', error.to_s)
   end
 
   def test_duplicate_ns
-    node = XML::Node.new('foo')
-    XML::Namespace.new(node, 'myname', 'http://www.mynamespace.com')
-    assert_raises(XML::Error) do
-      XML::Namespace.new(node, 'myname', 'http://www.mynamespace.com')
+    node = LibXML::XML::Node.new('foo')
+    LibXML::XML::Namespace.new(node, 'myname', 'http://www.mynamespace.com')
+    assert_raises(LibXML::XML::Error) do
+      LibXML::XML::Namespace.new(node, 'myname', 'http://www.mynamespace.com')
     end
   end
 
   def test_eql
-    node = XML::Node.new('Envelope')
+    node = LibXML::XML::Node.new('Envelope')
 
     assert(node.namespaces.namespace.eql?(node.namespaces.namespace))
   end
 
   def test_equal
-    node1 = XML::Node.new('Envelope')
-    ns1 = XML::Namespace.new(node1, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
+    node1 = LibXML::XML::Node.new('Envelope')
+    ns1 = LibXML::XML::Namespace.new(node1, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
 
-    node2 = XML::Node.new('Envelope')
-    ns2 = XML::Namespace.new(node2, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
+    node2 = LibXML::XML::Node.new('Envelope')
+    ns2 = LibXML::XML::Namespace.new(node2, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
 
     assert(ns1 == ns2)
   end

data/test/test_namespaces.rb

@@ -1,12 +1,12 @@
 # encoding: UTF-8
 
-require File.expand_path('../test_helper', __FILE__)
+require_relative './test_helper'
 
 
 class TestNamespaces < Minitest::Test
   def setup
     file = File.join(File.dirname(__FILE__), 'model/soap.xml')
-    @doc = XML::Document.file(file)
+    @doc = LibXML::XML::Document.file(file)
   end
 
   def teardown
@@ -28,10 +28,10 @@ class TestNamespaces < Minitest::Test
   end
 
   def test_set_namespace_node
-    node = XML::Node.new('Envelope')
+    node = LibXML::XML::Node.new('Envelope')
     assert_equal('<Envelope/>', node.to_s)
 
-    ns = XML::Namespace.new(node, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
+    ns = LibXML::XML::Namespace.new(node, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
     assert_equal("<Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\"/>", node.to_s)
     assert_nil(node.namespaces.namespace)
 
@@ -43,16 +43,16 @@ class TestNamespaces < Minitest::Test
 
   def test_set_namespace_attribute
     # Create node
-    node = XML::Node.new('Envelope')
+    node = LibXML::XML::Node.new('Envelope')
     assert_equal('<Envelope/>', node.to_s)
 
     # Create attribute
-    attr = XML::Attr.new(node, "encodingStyle", "http://www.w3.org/2001/12/soap-encoding")
+    attr = LibXML::XML::Attr.new(node, "encodingStyle", "http://www.w3.org/2001/12/soap-encoding")
     assert_equal('<Envelope encodingStyle="http://www.w3.org/2001/12/soap-encoding"/>',
                  node.to_s)
 
     # Create namespace attribute
-    ns = XML::Namespace.new(node, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
+    ns = LibXML::XML::Namespace.new(node, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
     assert_equal('<Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" encodingStyle="http://www.w3.org/2001/12/soap-encoding"/>',
                   node.to_s)
     assert_nil(node.namespaces.namespace)
@@ -71,19 +71,19 @@ class TestNamespaces < Minitest::Test
   end
 
   def test_define_namespace
-    node = XML::Node.new('Envelope')
+    node = LibXML::XML::Node.new('Envelope')
     assert_equal('<Envelope/>', node.to_s)
 
-    XML::Namespace.new(node, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
+    LibXML::XML::Namespace.new(node, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
     assert_equal("<Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\"/>", node.to_s)
     assert_nil(node.namespaces.namespace)
   end
 
   def test_define_default_namespace
-    node = XML::Node.new('Envelope')
+    node = LibXML::XML::Node.new('Envelope')
     assert_equal('<Envelope/>', node.to_s)
 
-    XML::Namespace.new(node, nil, 'http://schemas.xmlsoap.org/soap/envelope/')
+    LibXML::XML::Namespace.new(node, nil, 'http://schemas.xmlsoap.org/soap/envelope/')
     assert_equal("<Envelope xmlns=\"http://schemas.xmlsoap.org/soap/envelope/\"/>", node.to_s)
     # This seems wrong, but appears to be the way libxml works
     assert_nil(node.namespaces.namespace)
@@ -97,27 +97,27 @@ class TestNamespaces < Minitest::Test
     assert_equal(5, namespaces.length)
 
     namespace = namespaces[0]
-    assert_instance_of(XML::Namespace, namespace)
+    assert_instance_of(LibXML::XML::Namespace, namespace)
     assert_nil(namespace.prefix)
     assert_equal('http://services.somewhere.com', namespace.href)
 
     namespace = namespaces[1]
-    assert_instance_of(XML::Namespace, namespace)
+    assert_instance_of(LibXML::XML::Namespace, namespace)
     assert_equal('ns1', namespace.prefix)
     assert_equal('http://domain.somewhere.com', namespace.href)
 
     namespace = namespaces[2]
-    assert_instance_of(XML::Namespace, namespace)
+    assert_instance_of(LibXML::XML::Namespace, namespace)
     assert_equal('soap', namespace.prefix)
     assert_equal('http://schemas.xmlsoap.org/soap/envelope/', namespace.href)
 
     namespace = namespaces[3]
-    assert_instance_of(XML::Namespace, namespace)
+    assert_instance_of(LibXML::XML::Namespace, namespace)
     assert_equal('xsd', namespace.prefix)
     assert_equal('http://www.w3.org/2001/XMLSchema', namespace.href)
 
     namespace = namespaces[4]
-    assert_instance_of(XML::Namespace, namespace)
+    assert_instance_of(LibXML::XML::Namespace, namespace)
     assert_equal('xsi', namespace.prefix)
     assert_equal('http://www.w3.org/2001/XMLSchema-instance', namespace.href)
   end
@@ -127,17 +127,17 @@ class TestNamespaces < Minitest::Test
     assert_equal(3, ns_defs.size)
 
     namespace = ns_defs[0]
-    assert_instance_of(XML::Namespace, namespace)
+    assert_instance_of(LibXML::XML::Namespace, namespace)
     assert_equal('soap', namespace.prefix)
     assert_equal('http://schemas.xmlsoap.org/soap/envelope/', namespace.href)
 
     namespace = ns_defs[1]
-    assert_instance_of(XML::Namespace, namespace)
+    assert_instance_of(LibXML::XML::Namespace, namespace)
     assert_equal('xsd', namespace.prefix)
     assert_equal('http://www.w3.org/2001/XMLSchema', namespace.href)
 
     namespace = ns_defs[2]
-    assert_instance_of(XML::Namespace, namespace)
+    assert_instance_of(LibXML::XML::Namespace, namespace)
     assert_equal('xsi', namespace.prefix)
     assert_equal('http://www.w3.org/2001/XMLSchema-instance', namespace.href)
 
@@ -147,7 +147,7 @@ class TestNamespaces < Minitest::Test
     assert_equal(1, ns_defs.size)
 
     namespace = ns_defs[0]
-    assert_instance_of(XML::Namespace, namespace)
+    assert_instance_of(LibXML::XML::Namespace, namespace)
     assert_nil(namespace.prefix)
     assert_equal('http://services.somewhere.com', namespace.href)
   end
@@ -155,7 +155,7 @@ class TestNamespaces < Minitest::Test
   def test_find_by_prefix
     namespace = @doc.root.namespaces.find_by_prefix('soap')
 
-    assert_instance_of(XML::Namespace, namespace)
+    assert_instance_of(LibXML::XML::Namespace, namespace)
     assert_equal('soap', namespace.prefix)
     assert_equal('http://schemas.xmlsoap.org/soap/envelope/', namespace.href)
   end
@@ -168,7 +168,7 @@ class TestNamespaces < Minitest::Test
                            :ns1 => 'http://services.somewhere.com')
     namespace = node.namespaces.find_by_prefix(nil)
 
-    assert_instance_of(XML::Namespace, namespace)
+    assert_instance_of(LibXML::XML::Namespace, namespace)
     assert_nil(namespace.prefix)
     assert_equal('http://services.somewhere.com', namespace.href)
   end
@@ -179,19 +179,19 @@ class TestNamespaces < Minitest::Test
 
     namespace = node.namespaces.find_by_href('http://schemas.xmlsoap.org/soap/envelope/')
 
-    assert_instance_of(XML::Namespace, namespace)
+    assert_instance_of(LibXML::XML::Namespace, namespace)
     assert_equal('soap', namespace.prefix)
     assert_equal('http://schemas.xmlsoap.org/soap/envelope/', namespace.href)
   end
 
   def test_default_namespace
-    doc = XML::Document.string('<Envelope xmlns="http://schemas.xmlsoap.org/soap/envelope/"/>')
+    doc = LibXML::XML::Document.string('<Envelope xmlns="http://schemas.xmlsoap.org/soap/envelope/"/>')
     ns = doc.root.namespaces.default
     assert_equal(ns.href, 'http://schemas.xmlsoap.org/soap/envelope/')
   end
 
   def test_default_prefix
-    doc = XML::Document.string('<Envelope xmlns="http://schemas.xmlsoap.org/soap/envelope/"/>')
+    doc = LibXML::XML::Document.string('<Envelope xmlns="http://schemas.xmlsoap.org/soap/envelope/"/>')
     doc.root.namespaces.default_prefix = 'soap'
 
     node = doc.root.find_first('/soap:Envelope')

data/test/test_node.rb

@@ -1,19 +1,19 @@
 # encoding: UTF-8
 
-require File.expand_path('../test_helper', __FILE__)
+require_relative './test_helper'
 
 class TestNode < Minitest::Test
   def setup
     @file_name = "model/bands.utf-8.xml"
 
     # Strip spaces to make testing easier
-    XML.default_keep_blanks = false
+    LibXML::XML.default_keep_blanks = false
     file = File.join(File.dirname(__FILE__), @file_name)
-    @doc = XML::Document.file(file)
+    @doc = LibXML::XML::Document.file(file)
   end
   
   def teardown
-    XML.default_keep_blanks = true
+    LibXML::XML.default_keep_blanks = true
     @doc = nil
   end
 
@@ -23,52 +23,48 @@ class TestNode < Minitest::Test
   end
 
   def test_doc_class
-    assert_instance_of(XML::Document, @doc)
+    assert_instance_of(LibXML::XML::Document, @doc)
   end
 
   def test_doc_node_type
-    assert_equal XML::Node::DOCUMENT_NODE, @doc.node_type
+    assert_equal LibXML::XML::Node::DOCUMENT_NODE, @doc.node_type
   end
 
   def test_root_class
-    assert_instance_of(XML::Node, @doc.root)
+    assert_instance_of(LibXML::XML::Node, @doc.root)
   end
 
   def test_root_node_type
-    assert_equal XML::Node::ELEMENT_NODE, @doc.root.node_type
+    assert_equal LibXML::XML::Node::ELEMENT_NODE, @doc.root.node_type
   end
 
   def test_node_class
     for n in nodes
-      assert_instance_of(XML::Node, n)
+      assert_instance_of(LibXML::XML::Node, n)
     end
   end
 
   def test_context
     node = @doc.root
     context = node.context
-    assert_instance_of(XML::XPath::Context, context)
+    assert_instance_of(LibXML::XML::XPath::Context, context)
   end
 
   def test_find
-    assert_instance_of(XML::XPath::Object, self.nodes)
+    assert_instance_of(LibXML::XML::XPath::Object, self.nodes)
   end
 
   def test_node_child_get
     assert_instance_of(TrueClass, @doc.root.child?)
-    assert_instance_of(XML::Node, @doc.root.child)
+    assert_instance_of(LibXML::XML::Node, @doc.root.child)
 
-    if defined?(Encoding)
-      assert_equal(Encoding::UTF_8, @doc.root.child.name.encoding)
-      assert_equal("m\u00F6tley_cr\u00FCe", @doc.root.child.name)
-    else
-      assert_equal("m\303\266tley_cr\303\274e", @doc.root.child.name)
-    end
+    assert_equal(Encoding::UTF_8, @doc.root.child.name.encoding)
+    assert_equal("m\u00F6tley_cr\u00FCe", @doc.root.child.name)
   end
 
   def test_node_doc
     for n in nodes
-      assert_instance_of(XML::Document, n.doc) if n.document?
+      assert_instance_of(LibXML::XML::Document, n.doc) if n.document?
     end
   end
 
@@ -80,7 +76,7 @@ class TestNode < Minitest::Test
   def test_node_find
     nodes = @doc.root.find('./fixnum')
     for node in nodes
-      assert_instance_of(XML::Node, node)
+      assert_instance_of(LibXML::XML::Node, node)
     end
   end
 
@@ -96,7 +92,7 @@ class TestNode < Minitest::Test
     assert(node_a.eql?(node_b))
 
     file = File.join(File.dirname(__FILE__), @file_name)
-    doc2 = XML::Document.file(file)
+    doc2 = LibXML::XML::Document.file(file)
 
     node_a2 = doc2.find_first('*[@country]')
 
@@ -107,8 +103,8 @@ class TestNode < Minitest::Test
   end
 
   def test_equality_2
-    parent = XML::Node.new('parent')
-    child = XML::Node.new('child')
+    parent = LibXML::XML::Node.new('parent')
+    child = LibXML::XML::Node.new('child')
     parent << child
 
     node_a = child.parent
@@ -139,7 +135,7 @@ class TestNode < Minitest::Test
   end
 
   def test_base
-    doc = XML::Parser.string('<person />').parse
+    doc = LibXML::XML::Parser.string('<person />').parse
     assert_nil(doc.root.base_uri)
   end
 
@@ -152,7 +148,7 @@ class TestNode < Minitest::Test
   #
   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
+    node = LibXML::XML::Parser.string(text).parse.root
 		assert_equal text, node.to_s
 
 		text_noenc = '<bad-script>if (a < b || b > c) { return "text"; }<stop/>return ">>>snip<<<";</bad-script>'
@@ -172,7 +168,7 @@ class TestNode < Minitest::Test
   # 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
+    node = LibXML::XML::Parser.string(text).parse.root
 		affected = node.find('//text()')
 
 		check_escaping = lambda do |flag|
@@ -205,15 +201,15 @@ class TestNode < Minitest::Test
     node = @doc.root
 
     node.space_preserve = false
-    assert_equal XML::Node::SPACE_DEFAULT, node.space_preserve
+    assert_equal LibXML::XML::Node::SPACE_DEFAULT, node.space_preserve
 
     node.space_preserve = true
-    assert_equal XML::Node::SPACE_PRESERVE, node.space_preserve
+    assert_equal LibXML::XML::Node::SPACE_PRESERVE, node.space_preserve
   end
 
   def test_empty
     text = '<name> </name>'
-    doc = XML::Parser.string(text).parse
+    doc = LibXML::XML::Parser.string(text).parse
 
     node = doc.root
     assert(!node.empty?)
@@ -222,8 +218,18 @@ class TestNode < Minitest::Test
     assert(text_node.empty?)
   end
 
+  def test_save_no_empty_tags
+    node = LibXML::XML::Node.new('test')
+    assert_equal '<test/>', node.to_s
+
+    LibXML::XML.default_save_no_empty_tags = true
+    assert_equal '<test></test>', node.to_s
+
+    LibXML::XML.default_save_no_empty_tags = false
+  end
+
   def test_set_content
-    node = XML::Node.new('test')
+    node = LibXML::XML::Node.new('test')
     node.content = "unescaped & string"
     assert_equal("unescaped & string", node.content)
     assert_equal("<test>unescaped &amp; string</test>", node.to_s)