libxml-ruby 2.8.0 → 3.2.1

data/test/{tc_properties.rb → test_properties.rb}

@@ -1,15 +1,14 @@
 # encoding: UTF-8
 
-require './test_helper'
+require_relative './test_helper'
 
-require 'test/unit'
 
 # attributes is deprecated - use attributes instead.
 # Tests for backwards compatibility
 
-class Testattributes < Test::Unit::TestCase
+class Testattributes < Minitest::Test
   def setup()
-    xp = XML::Parser.string('<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>')
+    xp = LibXML::XML::Parser.string('<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>')
     @doc = xp.parse
   end
 
@@ -20,20 +19,20 @@ class Testattributes < Test::Unit::TestCase
   def test_traversal
     attributes = @doc.root.attributes
     
-    assert_instance_of(XML::Attributes, attributes)
+    assert_instance_of(LibXML::XML::Attributes, attributes)
     attribute = attributes.first
     assert_equal('uga', attribute.name)
     assert_equal('booga', attribute.value)
 
     attribute = attribute.next
-    assert_instance_of(XML::Attr, attribute)
+    assert_instance_of(LibXML::XML::Attr, attribute)
     assert_equal('foo', attribute.name)
     assert_equal('bar', attribute.value)
   end
   
   def test_no_attributes
     attributes = @doc.root.child.attributes
-    assert_instance_of(XML::Attributes, attributes)
+    assert_instance_of(LibXML::XML::Attributes, attributes)
     assert_equal(0, attributes.length)
   end
 end

data/test/test_reader.rb

@@ -0,0 +1,363 @@
+# encoding: UTF-8
+
+require_relative './test_helper'
+require 'stringio'
+
+class TestReader < Minitest::Test
+  XML_FILE = File.join(File.dirname(__FILE__), 'model/atom.xml')
+
+  def verify_simple(reader)
+    node_types = []
+
+    # Read each node
+    26.times do
+      assert(reader.read)
+      node_types << reader.node_type
+    end
+
+    # There are no more nodes
+    assert(!reader.read)
+
+    # Check what was read
+    expected = [LibXML::XML::Reader::TYPE_PROCESSING_INSTRUCTION,
+                LibXML::XML::Reader::TYPE_ELEMENT,
+                LibXML::XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
+                LibXML::XML::Reader::TYPE_COMMENT,
+                LibXML::XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
+                LibXML::XML::Reader::TYPE_ELEMENT,
+                LibXML::XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
+                LibXML::XML::Reader::TYPE_ELEMENT,
+                LibXML::XML::Reader::TYPE_CDATA,
+                LibXML::XML::Reader::TYPE_END_ELEMENT,
+                LibXML::XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
+                LibXML::XML::Reader::TYPE_ELEMENT,
+                LibXML::XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
+                LibXML::XML::Reader::TYPE_ELEMENT,
+                LibXML::XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
+                LibXML::XML::Reader::TYPE_ELEMENT,
+                LibXML::XML::Reader::TYPE_TEXT,
+                LibXML::XML::Reader::TYPE_END_ELEMENT,
+                LibXML::XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
+                LibXML::XML::Reader::TYPE_END_ELEMENT,
+                LibXML::XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
+                LibXML::XML::Reader::TYPE_END_ELEMENT,
+                LibXML::XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
+                LibXML::XML::Reader::TYPE_END_ELEMENT,
+                LibXML::XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
+                LibXML::XML::Reader::TYPE_END_ELEMENT]
+
+    assert_equal(expected, node_types)
+  end
+
+  def test_document
+    reader = LibXML::XML::Reader.document(LibXML::XML::Document.file(XML_FILE))
+    verify_simple(reader)
+  end
+
+  def test_file
+    reader = LibXML::XML::Reader.file(XML_FILE)
+    verify_simple(reader)
+  end
+
+  def test_invalid_file
+    assert_raises(LibXML::XML::Error) do
+      LibXML::XML::Reader.file('/does/not/exist')
+    end
+  end
+
+  def test_string
+    reader = LibXML::XML::Reader.string(File.read(XML_FILE))
+    verify_simple(reader)
+  end
+
+  def test_io
+    File.open(XML_FILE, 'rb') do |io|
+      reader = LibXML::XML::Reader.io(io)
+      verify_simple(reader)
+    end
+  end
+
+  def test_io_gc
+    # Test that the reader keeps a reference
+    # to the io object
+    file = File.open(XML_FILE, 'rb')
+    reader = LibXML::XML::Reader.io(file)
+    file = nil
+    GC.start
+    assert(reader.read)
+  end
+
+  def test_string_io
+    data = File.read(XML_FILE)
+    string_io = StringIO.new(data)
+    reader = LibXML::XML::Reader.io(string_io)
+    verify_simple(reader)
+  end
+
+  def test_error
+    reader = LibXML::XML::Reader.string('<foo blah')
+
+    error = assert_raises(LibXML::XML::Error) do
+      reader.read
+    end
+    assert_equal("Fatal error: Couldn't find end of Start Tag foo at :1.", error.to_s)
+  end
+
+  def test_attr
+    parser = LibXML::XML::Reader.string("<foo x='1' y='2'/>")
+    assert(parser.read)
+    assert_equal('foo', parser.name)
+    assert_equal('1', parser['x'])
+    assert_equal('1', parser[0])
+    assert_equal('2', parser['y'])
+    assert_equal('2', parser[1])
+    assert_nil(parser['z'])
+    assert_nil(parser[2])
+  end
+
+  def test_move_attr
+      reader = LibXML::XML::Reader.string('<root xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xhtml="http://www.w3.org/1999/xhtml"><link xml:id="abc" xlink:href="def" xhtml:class="ghi" bar="jkl" /></root>')
+      assert(reader.read) # <root/>
+      assert(reader.read) # <link/>
+
+      assert(reader.move_to_attribute_no(1))
+      assert_equal(reader.value, 'def')
+      assert(reader.move_to_attribute_ns('id', 'http://www.w3.org/XML/1998/namespace'))
+      assert_equal(reader.value, 'abc')
+      assert(reader.move_to_attribute('bar'))
+      assert_equal(reader.value, 'jkl')
+
+      # 1 in case of success, -1 in case of error, 0 if not found
+      assert_equal(reader.move_to_attribute_no(12), 0)
+      assert_equal(reader.move_to_attribute('baz'), 0)
+      assert_equal(reader.move_to_attribute_ns('baz', 'http://ruby/namespace'), 0)
+  end
+
+  def test_get_attr
+      reader = LibXML::XML::Reader.string('<root xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xhtml="http://www.w3.org/1999/xhtml"><link xml:id="abc" xlink:href="def" xhtml:class="ghi" bar="jkl" /></root>')
+      assert(reader.read) # <root/>
+      assert(reader.read) # <link/>
+
+      assert_equal(reader.get_attribute_no(1), 'def')
+      assert_equal(reader.get_attribute_ns('id', 'http://www.w3.org/XML/1998/namespace'), 'abc')
+      assert_equal(reader.get_attribute('bar'), 'jkl')
+
+      assert_nil(reader.get_attribute_no(12))
+      assert_nil(reader.get_attribute('baz'))
+      assert_nil(reader.get_attribute_ns('baz', 'http://ruby/namespace'))
+  end
+
+  def test_value
+    parser = LibXML::XML::Reader.string("<foo><bar>1</bar><bar>2</bar><bar>3</bar></foo>")
+    assert(parser.read)
+    assert_equal('foo', parser.name)
+    assert_nil(parser.value)
+    3.times do |i|
+      assert(parser.read)
+      assert_equal(LibXML::XML::Reader::TYPE_ELEMENT, parser.node_type)
+      assert_equal('bar', parser.name)
+      assert(parser.read)
+      assert_equal(LibXML::XML::Reader::TYPE_TEXT, parser.node_type)
+      assert_equal((i + 1).to_s, parser.value)
+      assert(parser.read)
+      assert_equal(LibXML::XML::Reader::TYPE_END_ELEMENT, parser.node_type)
+    end
+  end
+
+  def test_expand
+    reader = LibXML::XML::Reader.file(XML_FILE)
+    reader.read.to_s
+    reader.read
+
+    # Read a node
+    node = reader.expand
+    refute_nil(node.doc)
+    assert_equal('feed', node.name)
+    assert_equal(::Encoding::UTF_8, node.name.encoding) if defined?(::Encoding)
+  end
+
+  def test_expand_find
+    reader = LibXML::XML::Reader.file(XML_FILE)
+    reader.read.to_s
+    reader.read
+
+    # Read first node which
+    node = reader.expand
+    assert_equal('feed', node.name)
+
+    # We need to create document to use xpath
+    reader.doc
+
+    # Search for entries
+    entries = node.find('atom:entry', 'atom:http://www.w3.org/2005/Atom')
+
+    assert_equal(1, entries.length)
+  end
+
+  def test_expand_invalid
+    reader = LibXML::XML::Reader.file(XML_FILE)
+
+    # Expand a node before one has been read
+    node = reader.expand
+    assert_nil(node)
+  end
+
+  def test_expand_should_be_invalid
+    reader = LibXML::XML::Reader.file(XML_FILE)
+
+    # Read a couple of nodes
+    reader.read
+    reader.read
+
+    # Expand the node
+    node = reader.expand
+    assert_equal('feed', node.name)
+
+    # Read another node, this makes the last node invalid
+    reader.next
+
+    # The previous node is now invalid - this should be an error but isn't
+    assert_equal('feed', node.name)
+  end
+
+  def test_expand_incorrectly_use_returned_node
+    file = File.join(File.dirname(__FILE__), 'model/cwm_1_0.xml')
+    reader = LibXML::XML::Reader.file(file)
+
+    nodes = Array.new
+    while reader.read
+      node = reader.expand
+      refute_nil(node)
+      refute_nil(node.doc)
+
+      # NOTE - DO NOT do this in real code, these nodes are invalid after the next read. This *will* cause
+      # a segmentation fault next time the garbage collector runs.  The reason is the parent node will be
+      # called in the mark phase, but its underlying xml node will be gone.  Same goes for calling children,
+      # attributes, etc.  You must let go of the expanded node *before* calling xml reader again and
+      # call the garbage collector to be safe.
+      #refute_nil(node.parent)
+      nodes << node
+    end
+    assert(true)
+  end
+
+  def test_mode
+    reader = LibXML::XML::Reader.string('<xml/>')
+    assert_equal(LibXML::XML::Reader::MODE_INITIAL, reader.read_state)
+    reader.read
+    assert_equal(LibXML::XML::Reader::MODE_EOF, reader.read_state)
+  end
+
+  def test_bytes_consumed
+    reader = LibXML::XML::Reader.file(XML_FILE)
+    reader.read
+    assert_equal(428, reader.byte_consumed)
+  end
+
+  def test_node
+    LibXML::XML.default_line_numbers = true
+    reader = LibXML::XML::Reader.file(XML_FILE)
+
+    # first try to get a node
+    assert_nil(reader.node)
+
+    reader.read
+    assert_instance_of(LibXML::XML::Node, reader.node)
+  end
+
+  def test_base_uri
+    # UTF8:
+    # ö - c3 b6 in hex, \303\266 in octal
+    # ü - c3 bc in hex, \303\274 in octal
+    xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?><bands genre=\"metal\">\n  <m\303\266tley_cr\303\274e country=\"us\">An American heavy metal band formed in Los Angeles, California in 1981.</m\303\266tley_cr\303\274e>\n  <iron_maiden country=\"uk\">British heavy metal band formed in 1975.</iron_maiden>\n</bands>"
+    reader = LibXML::XML::Reader.string(xml, :base_uri => "http://libxml.rubyforge.org")
+
+    reader.read
+    assert_equal(reader.base_uri, "http://libxml.rubyforge.org")
+    assert_equal(::Encoding::UTF_8, reader.base_uri.encoding) if defined?(::Encoding)
+  end
+
+  def test_options
+    xml = <<-EOS
+      <!DOCTYPE foo [<!ENTITY foo 'bar'>]>
+      <test>
+        <cdata><![CDATA[something]]></cdata>
+        <entity>&foo;</entity>
+      </test>
+    EOS
+
+    # Parse normally
+    reader = LibXML::XML::Reader.string(xml)
+    reader.read # foo
+    reader.read # test
+    reader.read # text
+    reader.read # cdata
+    reader.read # cdata-section
+    assert_equal(LibXML::XML::Node::CDATA_SECTION_NODE, reader.node_type)
+
+    # Convert cdata section to text
+    reader = LibXML::XML::Reader.string(xml, :options => LibXML::XML::Parser::Options::NOCDATA)
+    reader.read # foo
+    reader.read # test
+    reader.read # text
+    reader.read # cdata
+    reader.read # cdata-section
+    assert_equal(LibXML::XML::Node::TEXT_NODE, reader.node_type)
+  end
+
+  def test_encoding
+    # ISO_8859_1:
+    # ö - f6 in hex, \366 in octal
+    # ü - fc in hex, \374 in octal
+    xml = "<?xml version=\"1.0\" encoding=\"iso-8859-1\"?><bands genre=\"metal\">\n  <m\366tley_cr\374e country=\"us\">An American heavy metal band formed in Los Angeles, California in 1981.</m\366tley_cr\374e>\n  <iron_maiden country=\"uk\">British heavy metal band formed in 1975.</iron_maiden>\n</bands>"
+
+    reader = LibXML::XML::Reader.string(xml, :encoding => LibXML::XML::Encoding::ISO_8859_1)
+    reader.read
+
+    assert_equal(Encoding::ISO8859_1, reader.read_outer_xml.encoding)
+    assert_equal(Encoding::ISO8859_1, reader.read_inner_xml.encoding)
+    assert_equal(Encoding::ISO8859_1, reader.read_string.encoding)
+
+    assert_equal("<bands genre=\"metal\">\n  <m\xC3\xB6tley_cr\xC3\xBCe country=\"us\">An American heavy metal band formed in Los Angeles, California in 1981.</m\xC3\xB6tley_cr\xC3\xBCe>\n  <iron_maiden country=\"uk\">British heavy metal band formed in 1975.</iron_maiden>\n</bands>".force_encoding(Encoding::ISO8859_1),
+                 reader.read_outer_xml)
+    assert_equal("\n  <m\xC3\xB6tley_cr\xC3\xBCe country=\"us\">An American heavy metal band formed in Los Angeles, California in 1981.</m\xC3\xB6tley_cr\xC3\xBCe>\n  <iron_maiden country=\"uk\">British heavy metal band formed in 1975.</iron_maiden>\n".force_encoding(Encoding::ISO8859_1),
+                 reader.read_inner_xml)
+    assert_equal("\n  An American heavy metal band formed in Los Angeles, California in 1981.\n  British heavy metal band formed in 1975.\n".force_encoding(Encoding::ISO8859_1),
+                 reader.read_string)
+  end
+
+  def test_invalid_encoding
+    # ISO_8859_1:
+    # ö - f6 in hex, \366 in octal
+    # ü - fc in hex, \374 in octal
+    xml = "<bands genre=\"metal\">\n  <m\366tley_cr\374e country=\"us\">An American heavy metal band formed in Los Angeles, California in 1981.</m\366tley_cr\374e>\n  <iron_maiden country=\"uk\">British heavy metal band formed in 1975.</iron_maiden>\n</bands>"
+
+    reader = LibXML::XML::Reader.string(xml)
+    error = assert_raises(LibXML::XML::Error) do
+      reader.read
+    end
+
+    assert_equal("Fatal error: Input is not proper UTF-8, indicate encoding !\nBytes: 0xF6 0x74 0x6C 0x65 at :2.",
+                 error.to_s)
+
+  end
+
+  def test_file_encoding
+    reader = LibXML::XML::Reader.file(XML_FILE)
+    reader.read
+    assert_equal(LibXML::XML::Encoding::UTF_8, reader.encoding)
+    assert_equal(Encoding::UTF_8, reader.value.encoding)
+  end
+
+  def test_string_encoding
+    # ISO_8859_1:
+    # ö - f6 in hex, \366 in octal
+    # ü - fc in hex, \374 in octal
+    xml = "<bands genre=\"metal\">\n  <m\366tley_cr\374e country=\"us\">An American heavy metal band formed in Los Angeles, California in 1981.</m\366tley_cr\374e>\n  <iron_maiden country=\"uk\">British heavy metal band formed in 1975.</iron_maiden>\n</bands>"
+    reader = LibXML::XML::Reader.string(xml, :encoding => LibXML::XML::Encoding::ISO_8859_1)
+    reader.read
+
+    # Encoding is always null for strings, very annoying!
+    assert_equal(reader.encoding, LibXML::XML::Encoding::NONE)
+  end
+end

data/test/test_relaxng.rb

@@ -0,0 +1,53 @@
+# encoding: UTF-8
+
+require_relative './test_helper'
+
+
+class TestRelaxNG < Minitest::Test
+  def setup
+    file = File.join(File.dirname(__FILE__), 'model/shiporder.xml')
+    @doc = LibXML::XML::Document.file(file)
+  end
+  
+  def teardown
+    @doc = nil
+  end
+  
+  def relaxng
+    document = LibXML::XML::Document.file(File.join(File.dirname(__FILE__), 'model/shiporder.rng'))
+    LibXML::XML::RelaxNG.document(document)
+  end
+
+  def test_from_doc
+    assert_instance_of(LibXML::XML::RelaxNG, relaxng)
+  end
+  
+  def test_valid
+    assert(@doc.validate_relaxng(relaxng))
+  end
+  
+  def test_invalid
+    new_node = LibXML::XML::Node.new('invalid', 'this will mess up validation')
+    @doc.root << new_node
+    
+    error = assert_raises(LibXML::XML::Error) do
+      @doc.validate_relaxng(relaxng)
+    end
+
+    refute_nil(error)
+    assert_kind_of(LibXML::XML::Error, error)
+    assert(error.message.match(/Error: Did not expect element invalid there/))
+    assert_equal(LibXML::XML::Error::RELAXNGV, error.domain)
+    assert_equal(LibXML::XML::Error::LT_IN_ATTRIBUTE, error.code)
+    assert_equal(LibXML::XML::Error::ERROR, error.level)
+    assert(error.file.match(/shiporder\.xml/))
+    assert_nil(error.line)
+    assert_equal('invalid', error.str1)
+    assert_nil(error.str2)
+    assert_nil(error.str3)
+    assert_equal(0, error.int1)
+    assert_equal(0, error.int2)
+    refute_nil(error.node)
+    assert_equal('invalid', error.node.name)
+  end
+end