libxml-ruby 3.2.2-x64-mingw-ucrt

data/test/test_sax_parser.rb

@@ -0,0 +1,326 @@
+# encoding: UTF-8
+
+require_relative './test_helper'
+require 'stringio'
+
+class DocTypeCallback
+  include LibXML::XML::SaxParser::Callbacks
+  def on_start_element(element, attributes)
+  end
+end
+
+class TestCaseCallbacks
+  include LibXML::XML::SaxParser::Callbacks
+
+  attr_accessor :result
+
+  def initialize
+    @result = Array.new
+  end
+
+  def on_cdata_block(cdata)
+    @result << "cdata: #{cdata}"
+  end
+
+  def on_characters(chars)
+    @result << "characters: #{chars}"
+  end
+
+  def on_comment(text)
+    @result << "comment: #{text}"
+  end
+
+  def on_end_document
+    @result << "end_document"
+  end
+
+  def on_end_element(name)
+    @result << "end_element: #{name}"
+  end
+
+  def on_end_element_ns(name, prefix, uri)
+    @result << "end_element_ns #{name}, prefix: #{prefix}, uri: #{uri}"
+  end
+
+  # Called for parser errors.
+  def on_error(error)
+    @result << "error: #{error}"
+  end
+
+  def on_processing_instruction(target, data)
+    @result << "pi: #{target} #{data}"
+  end
+
+  def on_start_document
+    @result << "startdoc"
+  end
+
+  def on_start_element(name, attributes)
+    attributes ||= Hash.new
+    @result << "start_element: #{name}, attr: #{attributes.inspect}"
+  end
+
+  def on_start_element_ns(name, attributes, prefix, uri, namespaces)
+    attributes ||= Hash.new
+    namespaces ||= Hash.new
+    @result << "start_element_ns: #{name}, attr: #{attributes.inspect}, prefix: #{prefix}, uri: #{uri}, ns: #{namespaces.inspect}"
+  end
+end
+
+class TestSaxParser < Minitest::Test
+  def saxtest_file
+    File.join(File.dirname(__FILE__), 'model/atom.xml')
+  end
+
+  def verify(parser)
+    result = parser.callbacks.result
+
+    i = -1
+    assert_equal("startdoc", result[i+=1])
+    assert_equal("pi: xml-stylesheet type=\"text/xsl\" href=\"my_stylesheet.xsl\"", result[i+=1])
+    assert_equal("start_element: feed, attr: {}", result[i+=1])
+    assert_equal("start_element_ns: feed, attr: {}, prefix: , uri: http://www.w3.org/2005/Atom, ns: {nil=>\"http://www.w3.org/2005/Atom\"}", result[i+=1])
+    assert_equal("characters: \n  ", result[i+=1])
+    assert_equal("comment:  Not a valid atom entry ", result[i+=1])
+    assert_equal("characters: \n  ", result[i+=1])
+    assert_equal("start_element: entry, attr: {}", result[i+=1])
+    assert_equal("start_element_ns: entry, attr: {}, prefix: , uri: http://www.w3.org/2005/Atom, ns: {}", result[i+=1])
+    assert_equal("characters: \n    ", result[i+=1])
+    assert_equal("start_element: title, attr: {\"type\"=>\"html\"}", result[i+=1])
+    assert_equal("start_element_ns: title, attr: {\"type\"=>\"html\"}, prefix: , uri: http://www.w3.org/2005/Atom, ns: {}", result[i+=1])
+    assert_equal("cdata: <<strong>>", result[i+=1])
+    assert_equal("end_element: title", result[i+=1])
+    assert_equal("end_element_ns title, prefix: , uri: http://www.w3.org/2005/Atom", result[i+=1])
+    assert_equal("characters: \n    ", result[i+=1])
+    assert_equal("start_element: content, attr: {\"type\"=>\"xhtml\"}", result[i+=1])
+    assert_equal("start_element_ns: content, attr: {\"type\"=>\"xhtml\"}, prefix: , uri: http://www.w3.org/2005/Atom, ns: {}", result[i+=1])
+    assert_equal("characters: \n      ", result[i+=1])
+    assert_equal("start_element: xhtml:div, attr: {}", result[i+=1])
+    assert_equal("start_element_ns: div, attr: {}, prefix: xhtml, uri: http://www.w3.org/1999/xhtml, ns: {\"xhtml\"=>\"http://www.w3.org/1999/xhtml\"}", result[i+=1])
+    assert_equal("characters: \n        ", result[i+=1])
+    assert_equal("start_element: xhtml:p, attr: {}", result[i+=1])
+    assert_equal("start_element_ns: p, attr: {}, prefix: xhtml, uri: http://www.w3.org/1999/xhtml, ns: {}", result[i+=1])
+    assert_equal("characters: hi there", result[i+=1])
+    assert_equal("end_element: xhtml:p", result[i+=1])
+    assert_equal("end_element_ns p, prefix: xhtml, uri: http://www.w3.org/1999/xhtml", result[i+=1])
+    assert_equal("characters: \n      ", result[i+=1])
+    assert_equal("end_element: xhtml:div", result[i+=1])
+    assert_equal("end_element_ns div, prefix: xhtml, uri: http://www.w3.org/1999/xhtml", result[i+=1])
+    assert_equal("characters: \n    ", result[i+=1])
+    assert_equal("end_element: content", result[i+=1])
+    assert_equal("end_element_ns content, prefix: , uri: http://www.w3.org/2005/Atom", result[i+=1])
+    assert_equal("characters: \n  ", result[i+=1])
+    assert_equal("end_element: entry", result[i+=1])
+    assert_equal("end_element_ns entry, prefix: , uri: http://www.w3.org/2005/Atom", result[i+=1])
+    assert_equal("characters: \n", result[i+=1])
+    assert_equal("end_element: feed", result[i+=1])
+    assert_equal("end_element_ns feed, prefix: , uri: http://www.w3.org/2005/Atom", result[i+=1])
+    assert_equal("end_document", result[i+=1])
+  end
+
+  def test_file
+    parser = LibXML::XML::SaxParser.file(saxtest_file)
+    parser.callbacks = TestCaseCallbacks.new
+    parser.parse
+    verify(parser)
+  end
+
+  def test_file_no_callbacks
+    parser = LibXML::XML::SaxParser.file(saxtest_file)
+    assert_equal true, parser.parse
+  end
+
+  def test_noexistent_file
+    error = assert_raises(LibXML::XML::Error) do
+      LibXML::XML::SaxParser.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
+      LibXML::XML::SaxParser.file(nil)
+    end
+
+    assert_match(/nil into String/, error.to_s)
+  end
+
+  def test_io
+    File.open(saxtest_file) do |file|
+      parser = LibXML::XML::SaxParser.io(file)
+      parser.callbacks = TestCaseCallbacks.new
+      parser.parse
+      verify(parser)
+    end
+  end
+
+  def test_nil_io
+    error = assert_raises(TypeError) do
+      LibXML::XML::HTMLParser.io(nil)
+    end
+
+    assert_equal("Must pass in an IO object", error.to_s)
+  end
+
+  def test_string_no_callbacks
+    xml = File.read(saxtest_file)
+    parser = LibXML::XML::SaxParser.string(xml)
+    assert_equal true, parser.parse
+  end
+
+  def test_string
+    xml = File.read(saxtest_file)
+    parser = LibXML::XML::SaxParser.string(xml)
+    parser.callbacks = TestCaseCallbacks.new
+    parser.parse
+    verify(parser)
+  end
+
+  def test_string_io
+    xml = File.read(saxtest_file)
+    io = StringIO.new(xml)
+    parser = LibXML::XML::SaxParser.io(io)
+
+    parser.callbacks = TestCaseCallbacks.new
+    parser.parse
+    verify(parser)
+  end
+
+  def test_nil_string
+    error = assert_raises(TypeError) do
+      LibXML::XML::SaxParser.string(nil)
+    end
+
+    assert_equal("wrong argument type nil (expected String)", error.to_s)
+  end
+
+  def test_doctype
+    xml = <<-EOS
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE Results SYSTEM "results.dtd">
+<Results>
+<a>a1</a>
+</Results>
+EOS
+    parser = LibXML::XML::SaxParser.string(xml)
+    parser.callbacks = DocTypeCallback.new
+    doc = parser.parse
+    refute_nil(doc)
+  end
+
+  def test_parse_warning
+    # Two xml PIs is a warning
+    xml = <<-EOS
+<?xml version="1.0" encoding="utf-8"?>
+<?xml-invalid?>
+<Test/>
+EOS
+
+    parser = LibXML::XML::SaxParser.string(xml)
+    parser.callbacks = TestCaseCallbacks.new
+
+    parser.parse
+
+    # Check callbacks
+    result = parser.callbacks.result
+    i = -1
+    assert_equal("startdoc", result[i+=1])
+    assert_equal("error: Warning: xmlParsePITarget: invalid name prefix 'xml' at :2.", result[i+=1])
+    assert_equal("pi: xml-invalid ", result[i+=1])
+    assert_equal("start_element: Test, attr: {}", result[i+=1])
+    assert_equal("start_element_ns: Test, attr: {}, prefix: , uri: , ns: {}", result[i+=1])
+    assert_equal("end_element: Test", result[i+=1])
+    assert_equal("end_element_ns Test, prefix: , uri: ", result[i+=1])
+    assert_equal("end_document", result[i+=1])
+  end
+
+  def test_parse_error
+    xml = <<-EOS
+      <Results>
+    EOS
+    parser = LibXML::XML::SaxParser.string(xml)
+    parser.callbacks = TestCaseCallbacks.new
+
+    error = assert_raises(LibXML::XML::Error) do
+      parser.parse
+    end
+
+    # Check callbacks
+    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_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_match(re_err_msg2, error.message)
+    assert_equal(LibXML::XML::Error::PARSER, error.domain)
+
+    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)
+    # 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([0, 1].include?(error.int1))
+    assert_equal(1, error.int2)
+    assert_nil(error.node)
+  end
+
+  def test_parse_seg_fail
+    xml = <<-EOS
+      <?xml version="1.0" encoding="ISO-8859-1" ?>
+      <Products>
+        <Product>
+          <ProductDescription>
+            AQUALIA THERMAL Lichte cr├иme - Versterkende & kalmerende 24 u hydraterende verzorging<br />
+            Huid wordt continu gehydrateerd, intens versterkt en gekalmeerd.<br />
+            Hypoallergeen. Geschikt voor de gevoelige huid.<br />
+            <br />
+            01.EFFECTIVITEIT<br />
+            Intensief gehydrateerd, de huid voelt gekalmeerd. Ze voelt de hele dag soepel en fluweelzacht aan, zonder een trekkerig gevoel. De huid is elastischer, soepeler en stralender. Doeltreffendheid getest onder dermatologisch toezicht. <br />
+            <br />
+            02.GEBRUIK<br />
+            's Morgens en/ of 's avonds aanbrengen. <br />
+            <br />
+            03.ACTIEVE INGREDIENTEN<br />
+            Technologische innovatie: 24 u continue cellulaire vochtnevel. Voor de 1ste keer worden Thermaal Bronwater van Vichy, rijk aan zeldzame mineralen en Actief HyaluronineтДв verwerkt in microcapsules, die deze vervolgens verspreiden in de cellen. <br />
+            <br />
+            04.TEXTUUR<br />
+            De lichte cr├иme is verfrissend en trekt makkelijk in. Niet vet en niet kleverig. Zonder 'maskereffect'. <br />
+            <br />
+            05.GEUR<br />
+            Geparfumeerd <br />
+            <br />
+            06.INHOUD<br />
+            40 ml tube <br />
+          </ProductDescription>
+        </Product>
+      </Products>
+    EOS
+
+    parser = LibXML::XML::SaxParser.string(xml)
+    parser.callbacks = TestCaseCallbacks.new
+
+    error = assert_raises(LibXML::XML::Error) do
+      parser.parse
+    end
+    assert_equal("Fatal error: xmlParseEntityRef: no name at :5.", error.to_s)
+
+    # Check callbacks
+    parser.callbacks.result
+  end
+end

data/test/test_schema.rb

@@ -0,0 +1,168 @@
+# encoding: UTF-8
+
+require_relative './test_helper'
+
+class TestSchema < 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 schema
+    document = LibXML::XML::Document.file(File.join(File.dirname(__FILE__), 'model/shiporder.xsd'))
+    LibXML::XML::Schema.document(document)
+  end
+
+  def check_error(error)
+    refute_nil(error)
+    assert(error.message.match(/Error: Element 'invalid': This element is not expected. Expected is \( item \)/))
+    assert_kind_of(LibXML::XML::Error, error)
+    assert_equal(LibXML::XML::Error::SCHEMASV, error.domain)
+    assert_equal(LibXML::XML::Error::SCHEMAV_ELEMENT_CONTENT, error.code)
+    assert_equal(LibXML::XML::Error::ERROR, error.level)
+    assert(error.file.match(/shiporder.xml/)) if error.file
+    assert_nil(error.str1)
+    assert_nil(error.str2)
+    assert_nil(error.str3)
+    assert_equal(0, error.int1)
+    assert_equal(0, error.int2)
+  end
+
+  def test_load_from_doc
+    assert_instance_of(LibXML::XML::Schema, schema)
+  end
+
+  def test_doc_valid
+    assert(@doc.validate_schema(schema))
+  end
+
+  def test_doc_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_schema(schema)
+    end
+
+    check_error(error)
+    assert_nil(error.line)
+    refute_nil(error.node)
+    assert_equal('invalid', error.node.name)
+  end
+
+  def test_reader_valid
+    reader = LibXML::XML::Reader.string(@doc.to_s)
+    assert(reader.schema_validate(schema))
+
+    while reader.read
+    end
+  end
+
+  def test_reader_invalid
+    # Set error handler
+    errors = Array.new
+    LibXML::XML::Error.set_handler do |error|
+      errors << error
+    end
+
+    new_node = LibXML::XML::Node.new('invalid', 'this will mess up validation')
+    @doc.root << new_node
+    reader = LibXML::XML::Reader.string(@doc.to_s)
+
+    # Set a schema
+    assert(reader.schema_validate(schema))
+
+    while reader.read
+    end
+
+    assert_equal(1, errors.length)
+
+    error = errors.first
+    check_error(error)
+    assert_equal(21, error.line)
+  ensure
+    LibXML::XML::Error.set_handler(&LibXML::XML::Error::VERBOSE_HANDLER)
+  end
+
+
+  # Schema meta-data tests
+  def test_elements
+    assert_instance_of(Hash, schema.elements)
+    assert_equal(1, schema.elements.length)
+    assert_instance_of(LibXML::XML::Schema::Element, schema.elements['shiporder'])
+  end
+
+  def test_types
+    assert_instance_of(Hash, schema.types)
+    assert_equal(1, schema.types.length)
+    assert_instance_of(LibXML::XML::Schema::Type, schema.types['shiporder'])
+  end
+
+  def test_imported_types
+    assert_instance_of(Hash, schema.imported_types)
+    assert_equal(1, schema.imported_types.length)
+    assert_instance_of(LibXML::XML::Schema::Type, schema.types['shiporder'])
+  end
+
+  def test_namespaces
+    assert_instance_of(Array, schema.namespaces)
+    assert_equal(1, schema.namespaces.length)
+  end
+
+  def test_schema_type
+    type = schema.types['shiporder']
+
+    assert_equal('shiporder', type.name)
+    assert_nil(type.namespace)
+    assert_equal("Shiporder type documentation", type.annotation)
+    assert_instance_of(LibXML::XML::Node, type.node)
+    assert_equal(LibXML::XML::Schema::Types::XML_SCHEMA_TYPE_COMPLEX, type.kind)
+    assert_instance_of(LibXML::XML::Schema::Type, type.base)
+    assert_equal("anyType", type.base.name)
+    assert_equal(LibXML::XML::Schema::Types::XML_SCHEMA_TYPE_BASIC, type.base.kind)
+
+    assert_instance_of(Hash, type.elements)
+    assert_equal(3, type.elements.length)
+  end
+
+  def test_schema_element
+    element = schema.types['shiporder'].elements['orderperson']
+
+    assert_equal('orderperson', element.name)
+    assert_nil(element.namespace)
+    assert_equal("orderperson element documentation", element.annotation)
+
+    element = schema.types['shiporder'].elements['item']
+    assert_equal('item', element.name)
+
+    element = schema.types['shiporder'].elements['item'].type.elements['note']
+    assert_equal('note', element.name)
+    assert_equal('string', element.type.name)
+  end
+
+  def test_schema_attributes
+    type = schema.types['shiporder']
+
+    assert_instance_of(Array, type.attributes)
+    assert_equal(2, type.attributes.length)
+    assert_instance_of(LibXML::XML::Schema::Attribute, type.attributes.first)
+  end
+
+  def test_schema_attribute
+    attribute = schema.types['shiporder'].attributes.first
+
+    assert_equal("orderid", attribute.name)
+    assert_nil(attribute.namespace)
+    assert_equal(1, attribute.occurs)
+    assert_equal('string', attribute.type.name)
+
+    attribute = schema.types['shiporder'].attributes[1]
+    assert_equal(2, attribute.occurs)
+    assert_equal('1', attribute.default)
+    assert_equal('integer', attribute.type.name)
+  end
+end

data/test/test_suite.rb

@@ -0,0 +1,48 @@
+# encoding: UTF-8
+
+# Change to current directory so relative
+# requires work.
+dir = File.dirname(__FILE__)
+Dir.chdir(dir)
+
+require './test_attr'
+require './test_attr_decl'
+require './test_attributes'
+require './test_canonicalize'
+require './test_document'
+require './test_document_write'
+require './test_dtd'
+require './test_error'
+require './test_html_parser'
+require './test_html_parser_context'
+require './test_namespace'
+require './test_namespaces'
+require './test_node'
+require './test_node_cdata'
+require './test_node_comment'
+require './test_node_copy'
+require './test_node_edit'
+require './test_node_pi'
+require './test_node_text'
+require './test_node_write'
+require './test_node_xlink'
+require './test_parser'
+require './test_parser_context'
+require './test_reader'
+require './test_relaxng'
+require './test_sax_parser'
+require './test_schema'
+require './test_traversal'
+require './test_writer'
+require './test_xinclude'
+require './test_xpath'
+require './test_xpath_context'
+require './test_xpath_expression'
+require './test_xpointer'
+
+require './test_encoding'
+require './test_encoding_sax'
+
+# Compatibility
+require './test_properties'
+require './test_deprecated_require'

data/test/test_traversal.rb

@@ -0,0 +1,152 @@
+# encoding: UTF-8
+
+require_relative './test_helper'
+
+class TestTranversal < Minitest::Test
+  ROOT_NODES_LENGTH = 27
+  ROOT_ELEMENTS_LENGTH = 13
+  
+  def setup
+    filename = File.join(File.dirname(__FILE__), 'model/books.xml')
+    @doc = LibXML::XML::Document.file(filename)
+  end
+  
+  def teardown
+    @doc = nil
+  end
+  
+  def test_children
+    # Includes text nodes and such
+    assert_equal(ROOT_NODES_LENGTH, @doc.root.children.length)
+  end
+  
+  def test_children_iteration
+    # Includes text nodes and such
+    nodes = @doc.root.children.inject([]) do |arr, node|
+      arr << node
+      arr
+    end
+    
+    assert_equal(ROOT_NODES_LENGTH, nodes.length)
+  end
+
+  def test_no_children
+    # Get a node with no children
+    node = @doc.find_first('/catalog/book[@id="bk113"]/price')
+    assert_equal(0, node.children.length)
+  end
+
+  def test_no_children_inner_xml
+    # Get a node with no children
+    node = @doc.find_first('/catalog/book[@id="bk113"]/price')
+    assert_nil(node.inner_xml)
+  end
+  def test_each
+    # Includes text nodes and such
+    nodes = @doc.root.inject([]) do |arr, node|
+      arr << node
+      arr
+    end
+    
+    assert_equal(ROOT_NODES_LENGTH, nodes.length)
+  end
+  
+  def test_each_element
+    # Includes text nodes and such
+    nodes = []
+    @doc.root.each_element do |node|
+      nodes << node
+    end
+    
+    assert_equal(ROOT_ELEMENTS_LENGTH, nodes.length)
+  end
+  
+  def test_next
+    nodes = []
+    
+    node = @doc.root.first
+    
+    while node
+      nodes << node
+      node = node.next
+    end
+    assert_equal(ROOT_NODES_LENGTH, nodes.length)
+  end
+
+  def test_next?
+    first_node = @doc.root.first
+    assert(first_node.next?)
+    
+    last_node = @doc.root.last
+    assert(!last_node.next?)
+  end
+    
+  def test_prev
+    nodes = []
+    
+    node = @doc.root.last
+    
+    while node
+      nodes << node
+      node = node.prev
+    end
+    assert_equal(ROOT_NODES_LENGTH, nodes.length)
+  end
+  
+  def test_prev?
+    first_node = @doc.root.first
+    assert(!first_node.prev?)
+    
+    last_node = @doc.root.last
+    assert(last_node.prev?)
+  end
+
+  def test_parent?
+    assert(!@doc.parent?)
+    assert(@doc.root.parent?)
+  end
+   
+  def test_child?
+    assert(@doc.child?)
+    assert(!@doc.root.first.child?)
+  end
+  
+  def test_next_prev_equivalence
+    next_nodes = []
+    last_nodes = []
+    
+    node = @doc.root.first
+    while node
+      next_nodes << node
+      node = node.next
+    end
+  
+    node = @doc.root.last
+    while node
+      last_nodes << node
+      node = node.prev
+    end
+    
+    assert_equal(next_nodes, last_nodes.reverse)
+  end
+  
+  def test_next_children_equivalence
+    next_nodes = []
+    
+    node = @doc.root.first
+    while node
+      next_nodes << node
+      node = node.next
+    end
+  
+    assert_equal(@doc.root.children, next_nodes)
+  end
+
+  def test_doc_class
+    assert_instance_of(LibXML::XML::Document, @doc)
+  end
+  
+  def test_root_class
+    assert_instance_of(LibXML::XML::Node, @doc.root)
+  end
+end