libxml-ruby 2.9.0-x64-mingw32

data/test/tc_node_pi.rb

@@ -0,0 +1,39 @@
+# encoding: UTF-8
+
+require './test_helper'
+
+
+class NodeCommentTest < Minitest::Test
+  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

data/test/tc_node_text.rb

@@ -0,0 +1,70 @@
+# encoding: UTF-8
+
+require './test_helper'
+
+class TestTextNode < Minitest::Test
+  def test_content
+    node = XML::Node.new_text('testdata')
+    assert_instance_of(XML::Node, node)
+    assert_equal('testdata', node.content)
+  end
+
+  def test_invalid_content
+    error = assert_raises(TypeError) do
+      node = 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 = 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 = 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

data/test/tc_node_write.rb

@@ -0,0 +1,107 @@
+# encoding: UTF-8
+
+require './test_helper'
+
+class TestNodeWrite < Minitest::Test
+  def setup
+    load_encoding("utf-8")
+  end
+  
+  def teardown
+    XML.default_keep_blanks = true
+    @doc = nil
+  end
+  
+  def load_encoding(name)
+    @encoding = Encoding.find(name) if defined?(Encoding)
+    @file_name = "model/bands.#{name.downcase}.xml"
+
+    # Strip spaces to make testing easier
+    XML.default_keep_blanks = false
+    file = File.join(File.dirname(__FILE__), @file_name)
+    @doc = 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("<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
+
+  def test_to_s_no_global_indentation
+    # No indentation due to global setting
+    node = @doc.root
+    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
+  end
+
+  def test_to_s_no_indentation
+    # No indentation due to local setting
+    node = @doc.root
+    assert_equal("<bands genre=\"metal\"><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></bands>",
+                 node.to_s(:indent => false))
+  end
+
+  def test_to_s_level
+    # No indentation due to local setting
+    node = @doc.root
+    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(:level => 1))
+  end
+
+  def test_to_s_encoding
+    # Test encodings
+    node = @doc.root
+
+    # 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)
+    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)
+    end
+
+    # Invalid encoding
+    error = assert_raises(ArgumentError) do
+      node.to_s(:encoding => -9999)
+    end
+    assert_equal('Unknown encoding value: -9999', error.to_s)
+  end
+
+  def test_inner_xml
+    # 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
+  end
+
+  # --- Debug ---
+  def test_debug
+    assert(@doc.root.debug)
+  end
+end

data/test/tc_node_xlink.rb

@@ -0,0 +1,28 @@
+# encoding: UTF-8
+
+# $Id$
+require './test_helper'
+
+
+class TC_XML_Node_XLink < Minitest::Test
+  def setup()
+    xp = 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(XML::Document, doc)
+    @root = doc.root
+    assert_instance_of(XML::Node, @root)
+  end
+
+  def teardown()
+    @root = nil
+  end
+
+  def test_xml_node_xlink()
+    for elem in @root.find('fixnum')
+      assert_instance_of(XML::Node, elem)
+      assert_instance_of(TrueClass, elem.xlink?)
+      assert_equal("simple", elem.xlink_type_name)
+      assert_equal(XML::Node::XLINK_TYPE_SIMPLE, elem.xlink_type)
+    end
+  end
+end

data/test/tc_parser.rb

@@ -0,0 +1,375 @@
+# encoding: UTF-8
+
+require './test_helper'
+require 'stringio'
+
+class TestParser < Minitest::Test
+  def setup
+    XML::Error.set_handler(&XML::Error::QUIET_HANDLER)
+  end
+
+  # -----  Sources  -------
+  def test_document
+    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/bands.utf-8.xml'))
+    parser = XML::Parser.file(file)
+    doc = parser.parse
+
+    parser = XML::Parser.document(doc)
+
+    doc = parser.parse
+
+    assert_instance_of(XML::Document, doc)
+    assert_instance_of(XML::Parser::Context, parser.context)
+  end
+
+  def test_nil_document
+    error = assert_raises(TypeError) do
+      XML::Parser.document(nil)
+    end
+
+    assert_equal("Must pass an XML::Document object", error.to_s)
+  end
+
+  def test_file
+    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
+
+    parser = XML::Parser.file(file)
+    doc = parser.parse
+    assert_instance_of(XML::Document, doc)
+    assert_instance_of(XML::Parser::Context, parser.context)
+  end
+
+  def test_noexistent_file
+    error = assert_raises(XML::Error) do
+      XML::Parser.file('i_dont_exist.xml')
+    end
+
+    assert_equal('Warning: failed to load external entity "i_dont_exist.xml".', error.to_s)
+  end
+
+  def test_nil_file
+    error = assert_raises(TypeError) do
+      XML::Parser.file(nil)
+    end
+
+    assert_match(/nil into String/, error.to_s)
+  end
+
+  def test_file_encoding
+    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/bands.utf-8.xml'))
+    parser = XML::Parser.file(file, :encoding => XML::Encoding::ISO_8859_1)
+
+    error = assert_raises(XML::Error) do
+      doc = parser.parse
+    end
+
+    assert(error.to_s.match(/Fatal error: Extra content at the end of the document/))
+
+    parser = XML::Parser.file(file, :encoding => XML::Encoding::UTF_8)
+    doc = parser.parse
+    refute_nil(doc)
+  end
+
+  def test_file_base_uri
+    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/bands.utf-8.xml'))
+
+    parser = XML::Parser.file(file)
+    doc = parser.parse
+    assert(doc.child.base_uri.match(/test\/model\/bands.utf-8.xml/))
+
+    parser = XML::Parser.file(file, :base_uri => "http://libxml.org")
+    doc = parser.parse
+    assert(doc.child.base_uri.match(/test\/model\/bands.utf-8.xml/))
+  end
+
+  def test_io
+    File.open(File.join(File.dirname(__FILE__), 'model/rubynet.xml')) do |io|
+      parser = XML::Parser.io(io)
+      assert_instance_of(XML::Parser, parser)
+
+      doc = parser.parse
+      assert_instance_of(XML::Document, doc)
+      assert_instance_of(XML::Parser::Context, parser.context)
+    end
+  end
+
+  def test_io_gc
+    # Test that the reader keeps a reference
+    # to the io object
+    file = File.open(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
+    parser = XML::Parser.io(file)
+    file = nil
+    GC.start
+    assert(parser.parse)
+  end
+
+  def test_nil_io
+    error = assert_raises(TypeError) do
+      XML::Parser.io(nil)
+    end
+
+    assert_equal("Must pass in an IO object", error.to_s)
+  end
+
+  def test_string_io
+    data = File.read(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
+    string_io = StringIO.new(data)
+    parser = XML::Parser.io(string_io)
+
+    doc = parser.parse
+    assert_instance_of(XML::Document, doc)
+    assert_instance_of(XML::Parser::Context, parser.context)
+  end
+
+  def test_string_io_thread
+    thread = Thread.new do
+      data = File.read(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
+      string_io = StringIO.new(data)
+      parser = XML::Parser.io(string_io)
+
+      doc = parser.parse
+      assert_instance_of(XML::Document, doc)
+      assert_instance_of(XML::Parser::Context, parser.context)
+    end
+
+    thread.join
+    assert(true)
+    puts 'Thread completed'
+  end
+
+  def test_string
+    str = '<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
+
+    parser = XML::Parser.string(str)
+    assert_instance_of(XML::Parser, parser)
+
+    doc = parser.parse
+    assert_instance_of(XML::Document, doc)
+    assert_instance_of(XML::Parser::Context, parser.context)
+  end
+
+  def test_nil_string
+    error = assert_raises(TypeError) do
+      XML::Parser.string(nil)
+    end
+
+    assert_equal("wrong argument type nil (expected String)", error.to_s)
+  end
+
+  def test_string_options
+    xml = <<-EOS
+      <!DOCTYPE foo [<!ENTITY foo 'bar'>]>
+      <test>
+        <cdata><![CDATA[something]]></cdata>
+        <entity>&foo;</entity>
+      </test>
+    EOS
+
+    XML::default_substitute_entities = false
+
+    # Parse normally
+    parser = XML::Parser.string(xml)
+    doc = parser.parse
+    assert_nil(doc.child.base_uri)
+
+    # Cdata section should be cdata nodes
+    node = doc.find_first('/test/cdata').child
+    assert_equal(XML::Node::CDATA_SECTION_NODE, node.node_type)
+
+    # Entities should not be subtituted
+    node = doc.find_first('/test/entity')
+    assert_equal('&foo;', node.child.to_s)
+
+    # Parse with options
+    parser = XML::Parser.string(xml, :base_uri => 'http://libxml.rubyforge.org',
+                                     :options => XML::Parser::Options::NOCDATA | XML::Parser::Options::NOENT)
+    doc = parser.parse
+    assert_equal(doc.child.base_uri, 'http://libxml.rubyforge.org')
+
+    # Cdata section should be text nodes
+    node = doc.find_first('/test/cdata').child
+    assert_equal(XML::Node::TEXT_NODE, node.node_type)
+
+    # Entities should be subtituted
+    node = doc.find_first('/test/entity')
+    assert_equal('bar', node.child.to_s)
+  end
+
+  def test_string_encoding
+    # ISO_8859_1:
+    # ö - f6 in hex, \366 in octal
+    # ü - fc in hex, \374 in octal
+
+    xml = <<-EOS
+      <bands>
+        <metal>m\366tley_cr\374e</metal>
+      </bands>
+    EOS
+
+    # Parse as UTF_8
+    parser = XML::Parser.string(xml, :encoding => XML::Encoding::UTF_8)
+
+    error = assert_raises(XML::Error) do
+      doc = parser.parse
+    end
+
+    assert_equal("Fatal error: Input is not proper UTF-8, indicate encoding !\nBytes: 0xF6 0x74 0x6C 0x65 at :2.",
+                 error.to_s)
+
+    # Parse as ISO_8859_1:
+    parser = XML::Parser.string(xml, :encoding => XML::Encoding::ISO_8859_1)
+    doc = parser.parse
+    node = doc.find_first('//metal')
+    if defined?(Encoding)
+      assert_equal(Encoding::UTF_8, node.content.encoding)
+      assert_equal("m\303\266tley_cr\303\274e", node.content)
+    else
+      assert_equal("m\303\266tley_cr\303\274e", node.content)
+    end
+  end
+
+  def test_fd_gc
+    # Test opening # of documents up to the file limit for the OS.
+    # Ideally it should run until libxml emits a warning,
+    # thereby knowing we've done a GC sweep. For the time being,
+    # re-open the same doc `limit descriptors` times.
+    # If we make it to the end, then we've succeeded,
+    # otherwise an exception will be thrown.
+    XML::Error.set_handler {|error|}
+
+    max_fd = if RUBY_PLATFORM.match(/mswin32|mingw/i)
+      500
+    else
+      Process.getrlimit(Process::RLIMIT_NOFILE)[0] + 1
+    end
+
+    file = File.join(File.dirname(__FILE__), 'model/rubynet.xml')
+    max_fd.times do
+       XML::Parser.file(file).parse
+    end
+    XML::Error.reset_handler {|error|}
+  end
+
+  def test_open_many_files
+    1000.times do
+      doc = XML::Parser.file('model/atom.xml').parse
+    end
+  end
+
+  # -----  Errors  ------
+  def test_error
+    error = assert_raises(XML::Error) do
+      XML::Parser.string('<foo><bar/></foz>').parse
+    end
+
+    refute_nil(error)
+    assert_kind_of(XML::Error, error)
+    assert_equal("Fatal error: Opening and ending tag mismatch: foo line 1 and foz at :1.", error.message)
+    assert_equal(XML::Error::PARSER, error.domain)
+    assert_equal(XML::Error::TAG_NAME_MISMATCH, error.code)
+    assert_equal(XML::Error::FATAL, error.level)
+    assert_nil(error.file)
+    assert_equal(1, error.line)
+    assert_equal('foo', error.str1)
+    assert_equal('foz', error.str2)
+    assert_nil(error.str3)
+    assert_equal(1, error.int1)
+    assert_equal(20, error.int2)
+    assert_nil(error.node)
+  end
+
+  def test_bad_xml
+    parser = XML::Parser.string('<ruby_array uga="booga" foo="bar"<fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>')
+    error = assert_raises(XML::Error) do
+      refute_nil(parser.parse)
+    end
+
+    refute_nil(error)
+    assert_kind_of(XML::Error, error)
+    assert_equal("Fatal error: Extra content at the end of the document at :1.", error.message)
+    assert_equal(XML::Error::PARSER, error.domain)
+    assert_equal(XML::Error::DOCUMENT_END, error.code)
+    assert_equal(XML::Error::FATAL, error.level)
+    assert_nil(error.file)
+    assert_equal(1, error.line)
+    assert_nil(error.str1)
+    assert_nil(error.str2)
+    assert_nil(error.str3)
+    assert_equal(0, error.int1)
+    assert_equal(34, error.int2)
+    assert_nil(error.node)
+  end
+
+  # Deprecated methods
+  def test_document_deprecated
+    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/bands.utf-8.xml'))
+    parser = XML::Parser.file(file)
+    doc = parser.parse
+
+    parser = XML::Parser.new
+    parser.document = doc
+    doc = parser.parse
+
+    assert_instance_of(XML::Document, doc)
+    assert_instance_of(XML::Parser::Context, parser.context)
+  end
+
+  def test_file_deprecated
+    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
+
+    parser = XML::Parser.new
+    parser.file = file
+    doc = parser.parse
+    assert_instance_of(XML::Document, doc)
+    assert_instance_of(XML::Parser::Context, parser.context)
+  end
+
+  def test_io_deprecated
+    File.open(File.join(File.dirname(__FILE__), 'model/rubynet.xml')) do |io|
+      parser = XML::Parser.new
+      assert_instance_of(XML::Parser, parser)
+      parser.io = io
+
+      doc = parser.parse
+      assert_instance_of(XML::Document, doc)
+      assert_instance_of(XML::Parser::Context, parser.context)
+    end
+  end
+
+  def test_string_deprecated
+    str = '<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
+
+    parser = XML::Parser.new
+    parser.string = str
+    assert_instance_of(XML::Parser, parser)
+
+    doc = parser.parse
+    assert_instance_of(XML::Document, doc)
+    assert_instance_of(XML::Parser::Context, parser.context)
+  end
+
+  def test_errors_from_background_thread
+    errors = []
+    background_errors = []
+
+    begin
+      XML::Error.set_handler do |error|
+        errors << error
+      end
+      parser = XML::Parser.string("<moo>")
+
+      thread = Thread.new do
+        XML::Error.set_handler do |error|
+          background_errors << error
+        end
+        parser.parse rescue nil
+      end
+      thread.join
+    ensure
+      XML::Error.set_handler(&XML::Error::QUIET_HANDLER)
+    end
+
+    assert_equal(errors.size, 0)
+    assert_equal(background_errors.size, 1)
+  end
+end