libxml-ruby 2.8.0 → 3.2.3

data/test/{tc_node_edit.rb → test_node_edit.rb}

@@ -1,11 +1,10 @@
 # encoding: UTF-8
 
-require './test_helper'
-require 'test/unit'
+require_relative './test_helper'
 
-class TestNodeEdit < Test::Unit::TestCase
+class TestNodeEdit < Minitest::Test
   def setup
-    xp = XML::Parser.string('<test><num>one</num><num>two</num><num>three</num></test>')
+    xp = LibXML::XML::Parser.string('<test><num>one</num><num>two</num><num>three</num></test>')
     @doc = xp.parse
   end
 
@@ -26,37 +25,37 @@ class TestNodeEdit < Test::Unit::TestCase
   end
 
   def test_add_next_01
-    first_node.next = XML::Node.new('num', 'one-and-a-half')
+    first_node.next = LibXML::XML::Node.new('num', 'one-and-a-half')
     assert_equal('<test><num>one</num><num>one-and-a-half</num><num>two</num><num>three</num></test>',
                  @doc.root.to_s.gsub(/\n\s*/,''))
   end
 
   def test_add_next_02
-    second_node.next = XML::Node.new('num', 'two-and-a-half')
+    second_node.next = LibXML::XML::Node.new('num', 'two-and-a-half')
     assert_equal('<test><num>one</num><num>two</num><num>two-and-a-half</num><num>three</num></test>',
                  @doc.root.to_s.gsub(/\n\s*/,''))
   end
 
   def test_add_next_03
-    third_node.next = XML::Node.new('num', 'four')
+    third_node.next = LibXML::XML::Node.new('num', 'four')
     assert_equal '<test><num>one</num><num>two</num><num>three</num><num>four</num></test>',
       @doc.root.to_s.gsub(/\n\s*/,'')
   end
 
   def test_add_prev_01
-    first_node.prev = XML::Node.new('num', 'half')
+    first_node.prev = LibXML::XML::Node.new('num', 'half')
     assert_equal '<test><num>half</num><num>one</num><num>two</num><num>three</num></test>',
       @doc.root.to_s.gsub(/\n\s*/,'')
   end
 
   def test_add_prev_02
-    second_node.prev = XML::Node.new('num', 'one-and-a-half')
+    second_node.prev = LibXML::XML::Node.new('num', 'one-and-a-half')
     assert_equal '<test><num>one</num><num>one-and-a-half</num><num>two</num><num>three</num></test>',
       @doc.root.to_s.gsub(/\n\s*/,'')
   end
 
   def test_add_prev_03
-    third_node.prev = XML::Node.new('num', 'two-and-a-half')
+    third_node.prev = LibXML::XML::Node.new('num', 'two-and-a-half')
     assert_equal '<test><num>one</num><num>two</num><num>two-and-a-half</num><num>three</num></test>',
       @doc.root.to_s.gsub(/\n\s*/,'')
   end
@@ -67,28 +66,12 @@ class TestNodeEdit < Test::Unit::TestCase
                  @doc.root.to_s.gsub(/\n\s*/,''))
   end
 
-  def test_freed_node
-    root = XML::Node.new("root")
-
-    a = XML::Node.new("a")
-    root << a
-
-    a.parent.remove!
-
-    # Node a has now been freed from under us
-    error = assert_raise(RuntimeError) do
-      a.to_s
-    end
-    assert_equal('This node has already been freed.', error.to_s)
-  end
-
   def test_remove_node_gc
-    xp = XML::Parser.string('<test><num>one</num><num>two</num><num>three</num></test>')
+    xp = LibXML::XML::Parser.string('<test><num>one</num><num>two</num><num>three</num></test>')
     doc = xp.parse
-    node = doc.root.child.remove!
-    node = nil
+    doc.root.child.remove!
     GC.start
-    assert_not_nil(doc)
+    refute_nil(doc)
   end
 
   def test_remove_node_iteration
@@ -105,7 +88,7 @@ class TestNodeEdit < Test::Unit::TestCase
   def test_reuse_removed_node
     # Remove the node
     node = @doc.root.first.remove!
-    assert_not_nil(node)
+    refute_nil(node)
 
     # Add it to the end of the document
     @doc.root.last.next = node
@@ -115,7 +98,7 @@ class TestNodeEdit < Test::Unit::TestCase
   end
 
   def test_append_existing_node
-    doc = XML::Parser.string('<top>a<bottom>b<one>first</one><two>second</two>c</bottom>d</top>').parse
+    doc = LibXML::XML::Parser.string('<top>a<bottom>b<one>first</one><two>second</two>c</bottom>d</top>').parse
     node1 = doc.find_first('//two')
 
     doc.root << node1
@@ -124,18 +107,17 @@ class TestNodeEdit < Test::Unit::TestCase
   end
 
   def test_wrong_doc
-    puts 333333
-    doc1 = XML::Parser.string('<nums><one></one></nums>').parse
-    doc2 = XML::Parser.string('<nums><two></two></nums>').parse
+    doc1 = LibXML::XML::Parser.string('<nums><one></one></nums>').parse
+    doc2 = LibXML::XML::Parser.string('<nums><two></two></nums>').parse
 
     node = doc1.root.child
 
-    error = assert_raise(XML::Error) do
+    error = assert_raises(LibXML::XML::Error) do
       doc2.root << node
     end
 
     GC.start
-    assert_equal(' Nodes belong to different documents.  You must first import the node by calling XML::Document.import.',
+    assert_equal(' Nodes belong to different documents.  You must first import the node by calling LibXML::XML::Document.import.',
                  error.to_s)
   end
 
@@ -145,11 +127,12 @@ class TestNodeEdit < Test::Unit::TestCase
 
     # Read in 500 documents
     500.times do
-      documents << XML::Parser.string(File.read(File.join(File.dirname(__FILE__), 'model', 'merge_bug_data.xml'))).parse
+      documents << LibXML::XML::Parser.string(File.read(File.join(File.dirname(__FILE__), 'model', 'merge_bug_data.xml'))).parse
     end
 
     master_doc = documents.shift
-    documents.inject(master_doc) do |master_doc, child_doc|
+
+    documents.each do |child_doc|
       master_body = master_doc.find("//body").first
       child_body = child_doc.find("//body").first
 
@@ -158,12 +141,11 @@ class TestNodeEdit < Test::Unit::TestCase
       end
 
       master_body << child_element.copy(true)
-      master_doc
     end
   end
 
   def test_append_chain
-    node = XML::Node.new('foo') << XML::Node.new('bar') << "bars contents"
+    node = LibXML::XML::Node.new('foo') << LibXML::XML::Node.new('bar') << "bars contents"
     assert_equal('<foo><bar/>bars contents</foo>',
                  node.to_s)
   end
@@ -173,4 +155,4 @@ class TestNodeEdit < Test::Unit::TestCase
     assert_equal("<test xml:base=\"http://www.rubynet.org/\">\n  <num>one</num>\n  <num>two</num>\n  <num>three</num>\n</test>",
                  @doc.root.to_s)
   end
-end
+end

data/test/{tc_node_pi.rb → test_node_pi.rb}

@@ -1,40 +1,37 @@
-# encoding: UTF-8
-
-require './test_helper'
-
-require 'test/unit'
-
-class NodeCommentTest < Test::Unit::TestCase
-  def setup
-    xp = XML::Parser.string('<root></root>')
-    @doc = xp.parse
-    assert_instance_of(XML::Document, @doc)
-    @root = @doc.root
-  end
-
-  def test_libxml_node_add_pi_01
-    @root << XML::Node.new_pi('mypi')
-    assert_equal '<root><?mypi?></root>',
-      @root.to_s.gsub(/\n\s*/,'')
-  end
-
-  def test_libxml_node_add_pi_02
-    @root << XML::Node.new_pi('mypi')
-    assert_equal 'pi',
-    @root.child.node_type_name
-  end
-
-  def test_libxml_node_add_pi_03
-    @root << el = XML::Node.new_pi('mypi')
-    el << "_this_is_added"
-    assert_equal '<root><?mypi _this_is_added?></root>',
-    @root.to_s.gsub(/\n\s*/,'')
-  end
-
-  def test_libxml_node_add_pi_04
-    @root << XML::Node.new_pi('mypi','mycontent')
-    assert_equal '<root><?mypi mycontent?></root>',
-      @root.to_s.gsub(/\n\s*/,'')
-  end
-
-end
+# encoding: UTF-8
+
+require_relative './test_helper'
+
+class NodePiTest < Minitest::Test
+  def setup
+    xp = LibXML::XML::Parser.string('<root></root>')
+    @doc = xp.parse
+    assert_instance_of(LibXML::XML::Document, @doc)
+    @root = @doc.root
+  end
+
+  def test_libxml_node_add_pi_01
+    @root << LibXML::XML::Node.new_pi('mypi')
+    assert_equal '<root><?mypi?></root>',
+      @root.to_s.gsub(/\n\s*/,'')
+  end
+
+  def test_libxml_node_add_pi_02
+    @root << LibXML::XML::Node.new_pi('mypi')
+    assert_equal 'pi',
+    @root.child.node_type_name
+  end
+
+  def test_libxml_node_add_pi_03
+    @root << el = LibXML::XML::Node.new_pi('mypi')
+    el << "_this_is_added"
+    assert_equal '<root><?mypi _this_is_added?></root>',
+    @root.to_s.gsub(/\n\s*/,'')
+  end
+
+  def test_libxml_node_add_pi_04
+    @root << LibXML::XML::Node.new_pi('mypi','mycontent')
+    assert_equal '<root><?mypi mycontent?></root>',
+      @root.to_s.gsub(/\n\s*/,'')
+  end
+end

data/test/{tc_node_text.rb → test_node_text.rb}

@@ -1,18 +1,17 @@
 # encoding: UTF-8
 
-require './test_helper'
-require 'test/unit'
+require_relative './test_helper'
 
-class TestTextNode < Test::Unit::TestCase
+class TestTextNode < Minitest::Test
   def test_content
-    node = XML::Node.new_text('testdata')
-    assert_instance_of(XML::Node, node)
+    node = LibXML::XML::Node.new_text('testdata')
+    assert_instance_of(LibXML::XML::Node, node)
     assert_equal('testdata', node.content)
   end
 
   def test_invalid_content
-    error = assert_raise(TypeError) do
-      node = XML::Node.new_text(nil)
+    error = assert_raises(TypeError) do
+      LibXML::XML::Node.new_text(nil)
     end
     assert_equal('wrong argument type nil (expected String)', error.to_s)
   end
@@ -24,11 +23,11 @@ class TestTextNode < Test::Unit::TestCase
 	# 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
+  def test_output_escaping
 		textnoenc = 'if (a < b || c > d) return "e";'
 		text = "if (a &lt; b || c &gt; d) return \"e\";"
  
-		node = XML::Node.new_text(textnoenc)
+		node = LibXML::XML::Node.new_text(textnoenc)
 		assert node.output_escaping?
 		assert_equal text, node.to_s
 
@@ -46,8 +45,8 @@ class TestTextNode < Test::Unit::TestCase
   end
 
 	# Just a sanity check for output escaping.
-	def test_output_escaping_sanity
-		node = XML::Node.new_text('testdata')
+  def test_output_escaping_sanity
+		node = LibXML::XML::Node.new_text('testdata')
     assert_equal 'text', node.name
 		assert node.output_escaping?
 
@@ -67,5 +66,4 @@ class TestTextNode < Test::Unit::TestCase
     assert_equal 'text', node.name
 		assert node.output_escaping?
   end
-
 end

data/test/{tc_node_write.rb → test_node_write.rb}

@@ -1,32 +1,31 @@
 # encoding: UTF-8
 
-require './test_helper'
-require 'test/unit'
+require_relative './test_helper'
 
-class TestNodeWrite < Test::Unit::TestCase
+class TestNodeWrite < Minitest::Test
   def setup
     load_encoding("utf-8")
   end
   
   def teardown
-    XML.default_keep_blanks = true
+    LibXML::XML.default_keep_blanks = true
     @doc = nil
   end
   
   def load_encoding(name)
-    @encoding = Encoding.find(name) if defined?(Encoding)
+    @encoding = Encoding.find(name)
     @file_name = "model/bands.#{name.downcase}.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 test_to_s_default
     # Default to_s has indentation
     node = @doc.root
-    assert_equal(Encoding::UTF_8, node.to_s.encoding) if defined?(Encoding)
+    assert_equal(Encoding::UTF_8, node.to_s.encoding)
     assert_equal("<bands genre=\"metal\">\n  <m\303\266tley_cr\303\274e country=\"us\">M\303\266tley Cr\303\274e is an American heavy metal band formed in Los Angeles, California in 1981.</m\303\266tley_cr\303\274e>\n  <iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>",
                  node.to_s)
   end
@@ -34,11 +33,11 @@ class TestNodeWrite < Test::Unit::TestCase
   def test_to_s_no_global_indentation
     # No indentation due to global setting
     node = @doc.root
-    XML.indent_tree_output = false
+    LibXML::XML.indent_tree_output = false
     assert_equal("<bands genre=\"metal\">\n<m\303\266tley_cr\303\274e country=\"us\">M\303\266tley Cr\303\274e is an American heavy metal band formed in Los Angeles, California in 1981.</m\303\266tley_cr\303\274e>\n<iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>",
                  node.to_s)
   ensure
-    XML.indent_tree_output = true
+    LibXML::XML.indent_tree_output = true
   end
 
   def test_to_s_no_indentation
@@ -62,26 +61,21 @@ class TestNodeWrite < Test::Unit::TestCase
     # UTF8:
     # ö - c3 b6 in hex, \303\266 in octal
     # ü - c3 bc in hex, \303\274 in octal
-    value = node.to_s(:encoding => XML::Encoding::UTF_8)
-    assert_equal(Encoding::UTF_8, node.to_s.encoding) if defined?(Encoding)
+    value = node.to_s(:encoding => LibXML::XML::Encoding::UTF_8)
+    assert_equal(Encoding::UTF_8, node.to_s.encoding)
     assert_equal("<bands genre=\"metal\">\n  <m\303\266tley_cr\303\274e country=\"us\">M\303\266tley Cr\303\274e is an American heavy metal band formed in Los Angeles, California in 1981.</m\303\266tley_cr\303\274e>\n  <iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>",
                  value)
 
     # ISO_8859_1:
     # ö - f6 in hex, \366 in octal
     # ü - fc in hex, \374 in octal
-    value = node.to_s(:encoding => XML::Encoding::ISO_8859_1)
-    if defined?(Encoding)
-      assert_equal(Encoding::ISO8859_1, value.encoding)
-      assert_equal("<bands genre=\"metal\">\n  <m\xF6tley_cr\xFCe country=\"us\">M\xF6tley Cr\xFCe is an American heavy metal band formed in Los Angeles, California in 1981.</m\xF6tley_cr\xFCe>\n  <iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>".force_encoding(Encoding::ISO8859_1),
-                   value)
-    else
-      assert_equal("<bands genre=\"metal\">\n  <m\xF6tley_cr\xFCe country=\"us\">M\xF6tley Cr\xFCe is an American heavy metal band formed in Los Angeles, California in 1981.</m\xF6tley_cr\xFCe>\n  <iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>",
+    value = node.to_s(:encoding => LibXML::XML::Encoding::ISO_8859_1)
+    assert_equal(Encoding::ISO8859_1, value.encoding)
+    assert_equal("<bands genre=\"metal\">\n  <m\xF6tley_cr\xFCe country=\"us\">M\xF6tley Cr\xFCe is an American heavy metal band formed in Los Angeles, California in 1981.</m\xF6tley_cr\xFCe>\n  <iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>".force_encoding(Encoding::ISO8859_1),
                  value)
-    end
 
     # Invalid encoding
-    error = assert_raise(ArgumentError) do
+    error = assert_raises(ArgumentError) do
       node.to_s(:encoding => -9999)
     end
     assert_equal('Unknown encoding value: -9999', error.to_s)
@@ -91,14 +85,9 @@ class TestNodeWrite < Test::Unit::TestCase
     # Default to_s has indentation
     node = @doc.root
 
-    if defined?(Encoding)
-      assert_equal(Encoding::UTF_8, node.inner_xml.encoding)
-      assert_equal("<m\u00F6tley_cr\u00FCe country=\"us\">M\u00F6tley Cr\u00FCe is an American heavy metal band formed in Los Angeles, California in 1981.</m\u00F6tley_cr\u00FCe><iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>",
-                   node.inner_xml)
-    else
-      assert_equal("<m\303\266tley_cr\303\274e country=\"us\">M\303\266tley Cr\303\274e is an American heavy metal band formed in Los Angeles, California in 1981.</m\303\266tley_cr\303\274e><iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>",
-                   node.inner_xml)
-    end
+    assert_equal(Encoding::UTF_8, node.inner_xml.encoding)
+    assert_equal("<m\u00F6tley_cr\u00FCe country=\"us\">M\u00F6tley Cr\u00FCe is an American heavy metal band formed in Los Angeles, California in 1981.</m\u00F6tley_cr\u00FCe><iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>",
+                 node.inner_xml)
   end
 
   # --- Debug ---

data/test/test_node_xlink.rb

@@ -0,0 +1,28 @@
+# encoding: UTF-8
+
+# $Id$
+require_relative './test_helper'
+
+
+class TC_XML_Node_XLink < Minitest::Test
+  def setup()
+    xp = LibXML::XML::Parser.string('<ruby_array xmlns:xlink="http://www.w3.org/1999/xlink/namespace/"><fixnum xlink:type="simple">one</fixnum></ruby_array>')
+    doc = xp.parse
+    assert_instance_of(LibXML::XML::Document, doc)
+    @root = doc.root
+    assert_instance_of(LibXML::XML::Node, @root)
+  end
+
+  def teardown()
+    @root = nil
+  end
+
+  def test_xml_node_xlink()
+    for elem in @root.find('fixnum')
+      assert_instance_of(LibXML::XML::Node, elem)
+      assert_instance_of(TrueClass, elem.xlink?)
+      assert_equal("simple", elem.xlink_type_name)
+      assert_equal(LibXML::XML::Node::XLINK_TYPE_SIMPLE, elem.xlink_type)
+    end
+  end
+end