libxml-ruby 3.2.0 → 3.2.3

data/test/model/shiporder.rnc

@@ -5,9 +5,9 @@
 #
 namespace xsi = "http://www.w3.org/2001/XMLSchema-instance"
 
-start = shiporder
+start = shiporderType
 
-shiporder  = element shiporder { attribute orderid { text }, 
+shiporderType  = element shiporder { attribute orderid { text },
                                  attribute xsi:noNamespaceSchemaLocation { text }, 
                                orderperson, shipto, item* }
 

data/test/model/shiporder.rng

@@ -7,9 +7,9 @@
 -->
 <grammar xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://relaxng.org/ns/structure/1.0">
   <start>
-    <ref name="shiporder"/>
+    <ref name="shiporderType"/>
   </start>
-  <define name="shiporder">
+  <define name="shiporderType">
     <element name="shiporder">
       <attribute name="orderid"/>
       <attribute name="xsi:noNamespaceSchemaLocation"/>

data/test/model/shiporder.xsd

@@ -1,8 +1,12 @@
 <?xml version="1.0" encoding="iso-8859-1" ?>
 <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
-  <xs:element name="shiporder" type="shiporder"/>
 
-  <xs:complexType name="shiporder">
+  <xs:import namespace="http://xml4r.org/ibxml-ruby/test/shiporder"
+             schemaLocation="shiporder_import.xsd"/>
+
+  <xs:element name="shiporder" type="shiporderType"/>
+
+  <xs:complexType name="shiporderType">
     <xs:annotation>
       <xs:documentation>Shiporder type documentation</xs:documentation>
     </xs:annotation>
@@ -37,4 +41,4 @@
     <xs:attribute name="foo" default="1" type="xs:integer" use="optional"/>
     <xs:attribute name="bar" use="prohibited"/>
   </xs:complexType>
-</xs:schema>
+</xs:schema>

data/test/model/shiporder_bad.xsd

@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="iso-8859-1" ?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+  <xs:element name="shiporder" type="shiporderType"/>
+
+  <xs:complexType name="shiporderType">
+    <xs:anntation>
+      <xs:documentation>Shiporder type documentation</xs:documentation>
+    </xs:anntation>
+    <xs:sequence>
+      <xs:element name="orderperson" type="xs:string">
+        <xs:annotation>
+          <xs:documentation>orderperson element documentation</xs:documentation>
+        </xs:annotation>
+      </xs:element>
+      <xs:element name="shipto">
+        <xs:complexType>
+          <xs:sequence>
+            <xs:element name="name" type="xs:string"/>
+            <xs:element name="address" type="xs:string"/>
+            <xs:element name="city" type="xs:string"/>
+            <xs:element name="country" type="xs:string"/>
+          </xs:sequence>
+        </xs:complexType>
+      </xs:element>
+      <xs:element name="item" maxOccurs="unbounded">
+        <xs:complexType>
+          <xs:seq>
+            <xs:element name="title" type="xs:string"/>
+            <xs:element name="note" type="xs:string" minOccurs="0"/>
+            <xs:element name="quantity" type="xs:positiveInteger"/>
+            <xs:element name="price" type="xs:decimal"/>
+          </xs:seq>
+        </xs:complexType>
+      </xs:element>
+    </xs:sequence>
+    <xs:attribute name="orderid" type="xs:string" use="required"/>
+    <xs:attribute name="foo" default="1" type="xs:integer" use="optional"/>
+    <xs:attribute name="bar" use="prohibited"/>
+  </xs:complexType>
+</xs:schema>

data/test/model/shiporder_import.xsd

@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="iso-8859-1" ?>
+<xs:schema xmlns="http://xml4r.org/libxml-ruby/test/shiporder"
+           xmlns:xs="http://www.w3.org/2001/XMLSchema"
+           targetNamespace="http://xml4r.org/libxml-ruby/test/shiporder">
+
+  <xs:element name="shiporder" type="shiporderFooType"/>
+  <xs:complexType name="shiporderFooType">
+    <xs:annotation>
+      <xs:documentation>Shiporder type documentation for Testing of imported schema</xs:documentation>
+    </xs:annotation>
+    <xs:sequence>
+      <xs:element name="orderperson" type="xs:string">
+        <xs:annotation>
+          <xs:documentation>orderperson element documentation</xs:documentation>
+        </xs:annotation>
+      </xs:element>
+      <xs:element name="shipto">
+        <xs:complexType>
+          <xs:sequence>
+            <xs:element name="name" type="xs:string"/>
+            <xs:element name="address" type="xs:string"/>
+            <xs:element name="city" type="xs:string"/>
+            <xs:element name="country" type="xs:string"/>
+            <xs:element name="phone" type="xs:string"/>
+          </xs:sequence>
+        </xs:complexType>
+      </xs:element>
+      <xs:element name="item" maxOccurs="unbounded">
+        <xs:complexType>
+          <xs:sequence>
+            <xs:element name="title" type="xs:string"/>
+            <xs:element name="note" type="xs:string" minOccurs="0"/>
+            <xs:element name="quantity" type="xs:positiveInteger"/>
+            <xs:element name="price" type="xs:decimal"/>
+            <xs:element name="discount" type="xs:decimal"/>
+          </xs:sequence>
+        </xs:complexType>
+      </xs:element>
+    </xs:sequence>
+    <xs:attribute name="orderid" type="xs:string" use="required"/>
+    <xs:attribute name="foo" default="1" type="xs:integer" use="optional"/>
+    <xs:attribute name="bar" type="xs:string" use="optional"/>
+    <xs:attribute name="xyzzy" type="xs:string" use="prohibited"/>
+  </xs:complexType>
+</xs:schema>

data/test/test_document.rb

@@ -13,119 +13,120 @@ class TestDocument < Minitest::Test
     @doc = nil
   end
 
-  # def test_klass
-  #   assert_instance_of(LibXML::XML::Document, @doc)
-  # end
-  #
-  # def test_context
-  #   context = @doc.context
-  #   assert_instance_of(LibXML::XML::XPath::Context, context)
-  # end
-  #
-  # def test_find
-  #   set = @doc.find('/ruby_array/fixnum')
-  #   assert_instance_of(LibXML::XML::XPath::Object, set)
-  #   assert_raises(NoMethodError) {
-  #     set.xpath
-  #   }
-  # end
-  #
-  # def test_compression
-  #   if LibXML::XML.enabled_zlib?
-  #     0.upto(9) do |i|
-  #       assert_equal(i, @doc.compression = i)
-  #       assert_equal(i, @doc.compression)
-  #     end
-  #
-  #     9.downto(0) do |i|
-  #       assert_equal(i, @doc.compression = i)
-  #       assert_equal(i, @doc.compression)
-  #     end
-  #
-  #     10.upto(20) do |i|
-  #       # assert_equal(9, @doc.compression = i)
-  #       assert_equal(i, @doc.compression = i) # This works around a bug in Ruby 1.8
-  #       assert_equal(9, @doc.compression)
-  #     end
-  #
-  #     -1.downto(-10) do |i|
-  #       # assert_equal(0, @doc.compression = i)
-  #       assert_equal(i, @doc.compression = i) # FIXME This bug should get fixed ASAP
-  #       assert_equal(0, @doc.compression)
-  #     end
-  #   end
-  # end
-  #
-  # def test_version
-  #   assert_equal('1.0', @doc.version)
-  #
-  #   doc = LibXML::XML::Document.new('6.9')
-  #   assert_equal('6.9', doc.version)
-  # end
-  #
-  # def test_write_root
-  #   @doc.root = LibXML::XML::Node.new('rubynet')
-  #   assert_instance_of(LibXML::XML::Node, @doc.root)
-  #   assert_instance_of(LibXML::XML::Document, @doc.root.doc)
-  #   assert_equal("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<rubynet/>\n",
-  #                @doc.to_s(:indent => false))
-  # end
-  #
-  # def test_doc_node_type
-  #   assert_equal(LibXML::XML::Node::DOCUMENT_NODE, LibXML::XML::Document.new.node_type)
-  # end
-  #
-  # def test_doc_node_type_name
-  #   assert_equal('document_xml', LibXML::XML::Document.new.node_type_name)
-  # end
-  #
-  # def test_xhtml
-	# 	doc = LibXML::XML::Document.new
-	# 	assert(!doc.xhtml?)
-  #   LibXML::XML::Dtd.new "-//W3C//DTD XHTML 1.0 Transitional//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", nil, doc, true
-	# 	assert(doc.xhtml?)
-  # end
-  #
-  # def test_document_root
-  #   doc1 = LibXML::XML::Document.string("<one/>")
-  #   doc2 = LibXML::XML::Document.string("<two/>")
-  #
-  #   error = assert_raises(LibXML::XML::Error) do
-  #     doc1.root = doc2.root
-  #   end
-  #   assert_equal(" Nodes belong to different documents.  You must first import the node by calling LibXML::XML::Document.import.",
-  #                error.to_s)
-  #
-  #   doc2.root << doc2.import(doc1.root)
-  #   assert_equal('<one/>', doc1.root.to_s)
-  #   assert_equal('<two><one/></two>', doc2.root.to_s(:indent => false))
-  #
-  #   assert(!doc1.root.equal?(doc2.root))
-  #   assert(doc1.root.doc != doc2.root.doc)
-  # end
-  #
-  # def test_import_node
-  #   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
-  #
-  #   assert_equal(" Nodes belong to different documents.  You must first import the node by calling LibXML::XML::Document.import.",
-  #                error.to_s)
-  #
-  #   doc2.root << doc2.import(node)
-  #
-  #   assert_equal("<nums><two/><one/></nums>",
-  #                doc2.root.to_s(:indent => false))
-  # end
+  def test_klass
+    assert_instance_of(LibXML::XML::Document, @doc)
+  end
+
+  def test_context
+    context = @doc.context
+    assert_instance_of(LibXML::XML::XPath::Context, context)
+  end
+
+  def test_find
+    set = @doc.find('/ruby_array/fixnum')
+    assert_instance_of(LibXML::XML::XPath::Object, set)
+    assert_raises(NoMethodError) {
+      set.xpath
+    }
+  end
+
+  def test_compression
+    if LibXML::XML.enabled_zlib?
+      0.upto(9) do |i|
+        assert_equal(i, @doc.compression = i)
+        assert_equal(i, @doc.compression)
+      end
+
+      9.downto(0) do |i|
+        assert_equal(i, @doc.compression = i)
+        assert_equal(i, @doc.compression)
+      end
+
+      10.upto(20) do |i|
+        # assert_equal(9, @doc.compression = i)
+        assert_equal(i, @doc.compression = i) # This works around a bug in Ruby 1.8
+        assert_equal(9, @doc.compression)
+      end
+
+      -1.downto(-10) do |i|
+        # assert_equal(0, @doc.compression = i)
+        assert_equal(i, @doc.compression = i) # FIXME This bug should get fixed ASAP
+        assert_equal(0, @doc.compression)
+      end
+    end
+  end
+
+  def test_version
+    assert_equal('1.0', @doc.version)
+
+    doc = LibXML::XML::Document.new('6.9')
+    assert_equal('6.9', doc.version)
+  end
+
+  def test_write_root
+    @doc.root = LibXML::XML::Node.new('rubynet')
+    assert_instance_of(LibXML::XML::Node, @doc.root)
+    assert_instance_of(LibXML::XML::Document, @doc.root.doc)
+    assert_equal("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<rubynet/>\n",
+                 @doc.to_s(:indent => false))
+  end
+
+  def test_doc_node_type
+    assert_equal(LibXML::XML::Node::DOCUMENT_NODE, LibXML::XML::Document.new.node_type)
+  end
+
+  def test_doc_node_type_name
+    assert_equal('document_xml', LibXML::XML::Document.new.node_type_name)
+  end
+
+  def test_xhtml
+		doc = LibXML::XML::Document.new
+		assert(!doc.xhtml?)
+    LibXML::XML::Dtd.new "-//W3C//DTD XHTML 1.0 Transitional//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", nil, doc, true
+		assert(doc.xhtml?)
+  end
+
+  def test_document_root
+    doc1 = LibXML::XML::Document.string("<one/>")
+    doc2 = LibXML::XML::Document.string("<two/>")
+
+    error = assert_raises(LibXML::XML::Error) do
+      doc1.root = doc2.root
+    end
+    assert_equal(" Nodes belong to different documents.  You must first import the node by calling LibXML::XML::Document.import.",
+                 error.to_s)
+
+    doc2.root << doc2.import(doc1.root)
+    assert_equal('<one/>', doc1.root.to_s)
+    assert_equal('<two><one/></two>', doc2.root.to_s(:indent => false))
+
+    assert(!doc1.root.equal?(doc2.root))
+    assert(doc1.root.doc != doc2.root.doc)
+  end
+
+  def test_import_node
+    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
+
+    assert_equal(" Nodes belong to different documents.  You must first import the node by calling LibXML::XML::Document.import.",
+                 error.to_s)
+
+    doc2.root << doc2.import(node)
+
+    assert_equal("<nums><two/><one/></nums>",
+                 doc2.root.to_s(:indent => false))
+  end
 
   def test_nonet
     xml_string = '<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
     xml = LibXML::XML::Document.string(xml_string, options: LibXML::XML::Parser::Options::NONET)
-    schema_document = LibXML::XML::Document.file('d:/src/libxml-ruby/test/model/atom.xml', options: LibXML::XML::Parser::Options::NONET)
+    file = File.join(File.dirname(__FILE__), 'model/atom.xml')
+    schema_document = LibXML::XML::Document.file(file, options: LibXML::XML::Parser::Options::NONET)
   end
 end

data/test/test_dtd.rb

@@ -84,7 +84,8 @@ class TestDtd < Minitest::Test
     assert_nil(error.file)
     assert_nil(error.line)
     assert_equal('invalid', error.str1)
-    assert_nil(error.str2)
+    # Different answers across operating systems
+    # assert_nil(error.str2)
     assert_nil(error.str3)
     assert_equal(0, error.int1)
     assert_equal(0, error.int2)

data/test/test_helper.rb

@@ -5,3 +5,5 @@
 require 'bundler/setup'
 require 'minitest/autorun'
 require 'libxml-ruby'
+
+STDOUT.write "\nlibxml2: #{LibXML::XML::LIBXML_VERSION}\n#{RUBY_DESCRIPTION}\n\n"

data/test/test_parser.rb

@@ -271,7 +271,7 @@ class TestParser < Minitest::Test
     assert_equal('foz', error.str2)
     assert_nil(error.str3)
     assert_equal(1, error.int1)
-    assert_equal(20, error.int2)
+    assert([18, 20].include?(error.int2))
     assert_nil(error.node)
   end
 

data/test/test_parser_context.rb

@@ -127,18 +127,12 @@ class TestParserContext < Minitest::Test
     end
   end
 
-  if ENV['NOTWORKING']
-    def test_num_chars
-      assert_equal(17, context.num_chars)
-    end
-  end
-
   def test_replace_entities
     context = LibXML::XML::Parser::Context.new
     assert(!context.replace_entities?)
 
-#    context.options = 1
- #   assert(context.replace_entities?)
+    context.options = LibXML::XML::Parser::Options::NOENT
+    assert(context.replace_entities?)
 
     context.options = 0
     assert(!context.replace_entities?)
@@ -185,7 +179,7 @@ class TestParserContext < Minitest::Test
     assert_nil(context.name_node)
     assert_equal(0, context.name_depth)
     assert_equal(10, context.name_depth_max)
-    assert_equal(17, context.num_chars)
+    assert([0, 17].include?(context.num_chars))
     assert_equal(false, context.replace_entities?)
     assert_equal(1, context.space_depth)
     assert_equal(10, context.space_depth_max)

data/test/test_reader.rb

@@ -249,9 +249,10 @@ class TestReader < Minitest::Test
   end
 
   def test_bytes_consumed
+    ending_are_rn = File.binread(XML_FILE).include? "\r\n"
     reader = LibXML::XML::Reader.file(XML_FILE)
     reader.read
-    assert_equal(428, reader.byte_consumed)
+    assert_equal(ending_are_rn ? 428 : 416, reader.byte_consumed)
   end
 
   def test_node

data/test/test_sax_parser.rb

@@ -181,7 +181,7 @@ class TestSaxParser < Minitest::Test
     xml = File.read(saxtest_file)
     io = StringIO.new(xml)
     parser = LibXML::XML::SaxParser.io(io)
-    
+
     parser.callbacks = TestCaseCallbacks.new
     parser.parse
     verify(parser)
@@ -250,25 +250,32 @@ EOS
     result = parser.callbacks.result
 
     i = -1
+
+    base_err_msg = "Fatal error: (Premature end of data in tag Results line 1|EndTag: '<\\/' not found) at :2\\."
+    re_err_msg1 = /\A(error: )#{base_err_msg}\z/
+    re_err_msg2 = /\A#{base_err_msg}\z/
+
     assert_equal("startdoc", result[i+=1])
     assert_equal("start_element: Results, attr: {}", result[i+=1])
     assert_equal("start_element_ns: Results, attr: {}, prefix: , uri: , ns: {}", result[i+=1])
     assert_equal("characters: \n", result[i+=1])
-    assert_equal("error: Fatal error: EndTag: '</' not found at :2.", result[i+=1])
+    assert_match(re_err_msg1, result[i+=1])
     assert_equal("end_document", result[i+=1])
 
     refute_nil(error)
     assert_kind_of(LibXML::XML::Error, error)
-    assert_equal("Fatal error: EndTag: '</' not found at :2.", error.message)
+    assert_match(re_err_msg2, error.message)
     assert_equal(LibXML::XML::Error::PARSER, error.domain)
-    assert_equal(LibXML::XML::Error::LTSLASH_REQUIRED, error.code)
+
+    assert([LibXML::XML::Error::TAG_NOT_FINISHED, LibXML::XML::Error::LTSLASH_REQUIRED].include?(error.code))
     assert_equal(LibXML::XML::Error::FATAL, error.level)
     assert_nil(error.file)
     assert_equal(2, error.line)
-    assert_nil(error.str1)
+    # Sometimes this is nil and sometimes its not depending on OS and libxlm version
+    # assert_nil(error.str1)
     assert_nil(error.str2)
     assert_nil(error.str3)
-    assert_equal(0, error.int1)
+    assert([0, 1].include?(error.int1))
     assert_equal(1, error.int2)
     assert_nil(error.node)
   end