libxml-ruby 3.2.2-x64-mingw-ucrt

data/test/test_node.rb

@@ -0,0 +1,237 @@
+# encoding: UTF-8
+
+require_relative './test_helper'
+
+class TestNode < Minitest::Test
+  def setup
+    @file_name = "model/bands.utf-8.xml"
+
+    # Strip spaces to make testing easier
+    LibXML::XML.default_keep_blanks = false
+    file = File.join(File.dirname(__FILE__), @file_name)
+    @doc = LibXML::XML::Document.file(file)
+  end
+  
+  def teardown
+    LibXML::XML.default_keep_blanks = true
+    @doc = nil
+  end
+
+  def nodes
+    # Find all nodes with a country attributes
+    @doc.find('*[@country]')
+  end
+
+  def test_doc_class
+    assert_instance_of(LibXML::XML::Document, @doc)
+  end
+
+  def test_doc_node_type
+    assert_equal LibXML::XML::Node::DOCUMENT_NODE, @doc.node_type
+  end
+
+  def test_root_class
+    assert_instance_of(LibXML::XML::Node, @doc.root)
+  end
+
+  def test_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(LibXML::XML::Node, n)
+    end
+  end
+
+  def test_context
+    node = @doc.root
+    context = node.context
+    assert_instance_of(LibXML::XML::XPath::Context, context)
+  end
+
+  def test_find
+    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(LibXML::XML::Node, @doc.root.child)
+
+    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(LibXML::XML::Document, n.doc) if n.document?
+    end
+  end
+
+  def test_name
+    node = @doc.root.children.last
+    assert_equal("iron_maiden", node.name)
+  end
+
+  def test_node_find
+    nodes = @doc.root.find('./fixnum')
+    for node in nodes
+      assert_instance_of(LibXML::XML::Node, node)
+    end
+  end
+
+  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))
+
+    file = File.join(File.dirname(__FILE__), @file_name)
+    doc2 = LibXML::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)
+    refute(node_a.equal?(node_a2))
+  end
+
+  def test_equality_2
+    parent = LibXML::XML::Node.new('parent')
+    child = LibXML::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
+    node = @doc.root
+    assert(node != nil)
+  end
+
+  def test_equality_wrong_type
+    node = @doc.root
+
+    assert_raises(TypeError) do
+      assert(node != 'abc')
+    end
+  end
+
+  def test_content
+    node = @doc.root.last
+    assert_equal("Iron Maiden is a British heavy metal band formed in 1975.",
+                 node.content)
+  end
+
+  def test_base
+    doc = LibXML::XML::Parser.string('<person />').parse
+    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
+		text = '<bad-script>if (a &lt; b || b &gt; c) { return "text"; }<stop/>return "&gt;&gt;&gt;snip&lt;&lt;&lt;";</bad-script>'
+    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>'
+		node.output_escaping = false
+		assert_equal text_noenc, node.to_s
+
+		node.output_escaping = true
+		assert_equal text, node.to_s
+
+		node.output_escaping = nil
+		assert_equal text_noenc, node.to_s
+
+		node.output_escaping = true
+		assert_equal text, node.to_s
+  end
+
+  # 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 = LibXML::XML::Parser.string(text).parse.root
+		affected = node.find('//text()')
+
+		check_escaping = lambda do |flag|
+			assert_equal('bad-script', node.name)
+			assert_equal(flag, node.output_escaping?)
+			affected.each do |x|
+				assert_equal(flag ? 'text' : 'textnoenc', x.name)
+				assert_equal(flag, x.output_escaping?)
+			end
+		end
+
+		node.output_escaping = false
+		check_escaping[false]
+
+		node.output_escaping = true
+		check_escaping[true]
+
+		node.output_escaping = nil
+		check_escaping[false]
+
+		node.output_escaping = true
+		check_escaping[true]
+
+		affected.first.output_escaping = true
+		affected.last.output_escaping = false
+		assert node.output_escaping?.nil?
+  end
+
+  def test_space_preserve
+    node = @doc.root
+
+    node.space_preserve = false
+    assert_equal LibXML::XML::Node::SPACE_DEFAULT, node.space_preserve
+
+    node.space_preserve = true
+    assert_equal LibXML::XML::Node::SPACE_PRESERVE, node.space_preserve
+  end
+
+  def test_empty
+    text = '<name> </name>'
+    doc = LibXML::XML::Parser.string(text).parse
+
+    node = doc.root
+    assert(!node.empty?)
+
+    text_node = node.first
+    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 = 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)
+  end
+end

data/test/test_node_cdata.rb

@@ -0,0 +1,50 @@
+# encoding: UTF-8
+
+require_relative './test_helper'
+
+class CDataCommentTest < 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_node_type
+    cnode = LibXML::XML::Node.new_cdata('test cdata')
+    assert_equal(LibXML::XML::Node::CDATA_SECTION_NODE, cnode.node_type)
+  end
+
+  def test_add_cdata
+    @root << LibXML::XML::Node.new_cdata('mycdata')
+    assert_equal '<root><![CDATA[mycdata]]></root>',
+      @root.to_s.gsub(/\n\s*/,'')
+  end
+
+  def test_add_cdata_2
+    @root << LibXML::XML::Node.new_cdata('mycdata')
+    assert_equal 'cdata',
+    @root.child.node_type_name
+  end
+
+  def test_add_cdata_3
+    @root << el = LibXML::XML::Node.new_cdata('mycdata')
+    el << "_this_is_added"
+    assert_equal '<root><![CDATA[mycdata_this_is_added]]></root>',
+      @root.to_s.gsub(/\n\s*/,'')
+  end
+  
+  def test_attributes
+    cnode = LibXML::XML::Node.new_cdata('test cdata')
+    assert_equal(0, cnode.attributes.length)
+  end
+  
+  def test_set_cdata_attribute
+    cnode = LibXML::XML::Node.new_cdata('test cdata')
+    
+    # Can't create attributes on non-element nodes
+    assert_raises(ArgumentError) do
+      cnode['attr'] = '123'
+    end
+  end
+end

data/test/test_node_comment.rb

@@ -0,0 +1,32 @@
+# encoding: UTF-8
+
+require_relative './test_helper'
+
+
+class NodeCommentTest < 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_comment_01
+    @root << LibXML::XML::Node.new_comment('mycomment')
+    assert_equal '<root><!--mycomment--></root>',
+      @root.to_s.gsub(/\n\s*/,'')
+  end
+
+  def test_libxml_node_add_comment_02
+    @root << LibXML::XML::Node.new_comment('mycomment')
+    assert_equal 'comment',
+    @root.child.node_type_name
+  end
+
+  def test_libxml_node_add_comment_03
+    @root << el = LibXML::XML::Node.new_comment('mycomment')
+    el << "_this_is_added"
+    assert_equal '<root><!--mycomment_this_is_added--></root>',
+    @root.to_s.gsub(/\n\s*/,'')
+  end
+end

data/test/test_node_copy.rb

@@ -0,0 +1,40 @@
+# encoding: UTF-8
+
+require_relative './test_helper'
+
+# see mailing list archive
+# [libxml-devel] Segmentation fault when add the cloned/copied node
+# 2007/11/27 20:51
+
+class TestNodeCopy < Minitest::Test
+  def setup
+    str = <<-STR
+      <html><body>
+        <div class="textarea" id="t1" style="STATIC">foo</div>
+        <div class="textarea" id="t2" style="STATIC">bar</div>
+      </body></html>
+    STR
+
+    doc = LibXML::XML::Parser.string(str).parse
+
+    xpath = "//div"
+    @div1 = doc.find(xpath).to_a[0]
+    @div2 = doc.find(xpath).to_a[1]
+  end
+
+  def test_libxml_node_copy_not_segv
+    @div2.each do |child|
+      c = child.copy(false)
+      @div1 << c
+    end
+    assert @div1.to_s =~ /foo/
+  end
+
+  def test_libxml_node_clone_not_segv
+    @div2.each do |child|
+      c = child.clone
+      @div1 << c
+    end
+    assert @div1.to_s =~ /foo/
+  end
+end

data/test/test_node_edit.rb

@@ -0,0 +1,158 @@
+# encoding: UTF-8
+
+require_relative './test_helper'
+
+class TestNodeEdit < Minitest::Test
+  def setup
+    xp = LibXML::XML::Parser.string('<test><num>one</num><num>two</num><num>three</num></test>')
+    @doc = xp.parse
+  end
+
+  def teardown
+    @doc = nil
+  end
+
+  def first_node
+    @doc.root.child
+  end
+
+  def second_node
+    first_node.next
+  end
+
+  def third_node
+    second_node.next
+  end
+
+  def test_add_next_01
+    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 = 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 = 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 = 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 = 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 = 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_remove_node
+    first_node.remove!
+    assert_equal('<test><num>two</num><num>three</num></test>',
+                 @doc.root.to_s.gsub(/\n\s*/,''))
+  end
+
+  def test_remove_node_gc
+    xp = LibXML::XML::Parser.string('<test><num>one</num><num>two</num><num>three</num></test>')
+    doc = xp.parse
+    doc.root.child.remove!
+    GC.start
+    refute_nil(doc)
+  end
+
+  def test_remove_node_iteration
+    nodes = Array.new
+    @doc.root.each_element do |node|
+      if node.name == 'num'
+        nodes << node
+        node.remove!
+      end
+    end
+    assert_equal(3, nodes.length)
+  end
+
+  def test_reuse_removed_node
+    # Remove the node
+    node = @doc.root.first.remove!
+    refute_nil(node)
+
+    # Add it to the end of the document
+    @doc.root.last.next = node
+
+    assert_equal('<test><num>two</num><num>three</num><num>one</num></test>',
+                 @doc.root.to_s.gsub(/\n\s*/,''))
+  end
+
+  def test_append_existing_node
+    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
+    assert_equal('<top>a<bottom>b<one>first</one>c</bottom>d<two>second</two></top>',
+                 doc.root.to_s)
+  end
+
+  def test_wrong_doc
+    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_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 LibXML::XML::Document.import.',
+                 error.to_s)
+  end
+
+  # This test is to verify that an earlier reported bug has been fixed
+  def test_merge
+    documents = []
+
+    # Read in 500 documents
+    500.times do
+      documents << LibXML::XML::Parser.string(File.read(File.join(File.dirname(__FILE__), 'model', 'merge_bug_data.xml'))).parse
+    end
+
+    master_doc = documents.shift
+
+    documents.each do |child_doc|
+      master_body = master_doc.find("//body").first
+      child_body = child_doc.find("//body").first
+
+      child_element = child_body.detect do |node|
+        node.element?
+      end
+
+      master_body << child_element.copy(true)
+    end
+  end
+
+  def test_append_chain
+    node = LibXML::XML::Node.new('foo') << LibXML::XML::Node.new('bar') << "bars contents"
+    assert_equal('<foo><bar/>bars contents</foo>',
+                 node.to_s)
+  end
+
+  def test_set_base
+    @doc.root.base_uri = 'http://www.rubynet.org/'
+    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

data/test/test_node_pi.rb

@@ -0,0 +1,37 @@
+# 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/test_node_text.rb

@@ -0,0 +1,69 @@
+# encoding: UTF-8
+
+require_relative './test_helper'
+
+class TestTextNode < Minitest::Test
+  def test_content
+    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_raises(TypeError) do
+      LibXML::XML::Node.new_text(nil)
+    end
+    assert_equal('wrong argument type nil (expected String)', error.to_s)
+  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
+		textnoenc = 'if (a < b || c > d) return "e";'
+		text = "if (a &lt; b || c &gt; d) return \"e\";"
+ 
+		node = LibXML::XML::Node.new_text(textnoenc)
+		assert node.output_escaping?
+		assert_equal text, node.to_s
+
+		node.output_escaping = false
+		assert_equal textnoenc, node.to_s
+
+		node.output_escaping = true
+		assert_equal text, node.to_s
+
+		node.output_escaping = nil
+		assert_equal textnoenc, node.to_s
+
+		node.output_escaping = true
+		assert_equal text, node.to_s
+  end
+
+	# Just a sanity check for output escaping.
+  def test_output_escaping_sanity
+		node = LibXML::XML::Node.new_text('testdata')
+    assert_equal 'text', node.name
+		assert node.output_escaping?
+
+		node.output_escaping = false
+    assert_equal 'textnoenc', node.name
+		assert ! node.output_escaping?
+
+		node.output_escaping = true
+    assert_equal 'text', node.name
+		assert node.output_escaping?
+
+		node.output_escaping = nil
+    assert_equal 'textnoenc', node.name
+		assert ! node.output_escaping?
+
+		node.output_escaping = true
+    assert_equal 'text', node.name
+		assert node.output_escaping?
+  end
+end