libxml-ruby 2.9.0-x64-mingw32

data/test/tc_relaxng.rb

@@ -0,0 +1,53 @@
+# encoding: UTF-8
+
+require './test_helper'
+
+
+class TestRelaxNG < Minitest::Test
+  def setup
+    file = File.join(File.dirname(__FILE__), 'model/shiporder.xml')
+    @doc = XML::Document.file(file)
+  end
+  
+  def teardown
+    @doc = nil
+  end
+  
+  def relaxng
+    document = XML::Document.file(File.join(File.dirname(__FILE__), 'model/shiporder.rng'))
+    relaxng = XML::RelaxNG.document(document)
+  end
+
+  def test_from_doc
+    assert_instance_of(XML::RelaxNG, relaxng)
+  end
+  
+  def test_valid
+    assert(@doc.validate_relaxng(relaxng))
+  end
+  
+  def test_invalid
+    new_node = XML::Node.new('invalid', 'this will mess up validation')
+    @doc.root << new_node
+    
+    error = assert_raises(XML::Error) do
+      @doc.validate_relaxng(relaxng)
+    end
+
+    refute_nil(error)
+    assert_kind_of(XML::Error, error)
+    assert(error.message.match(/Error: Did not expect element invalid there/))
+    assert_equal(XML::Error::RELAXNGV, error.domain)
+    assert_equal(XML::Error::LT_IN_ATTRIBUTE, error.code)
+    assert_equal(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

data/test/tc_sax_parser.rb

@@ -0,0 +1,319 @@
+# encoding: UTF-8
+
+require './test_helper'
+require 'stringio'
+
+class DocTypeCallback
+  include XML::SaxParser::Callbacks
+  def on_start_element(element, attributes)
+  end
+end
+
+class TestCaseCallbacks
+  include 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 = XML::SaxParser.file(saxtest_file)
+    parser.callbacks = TestCaseCallbacks.new
+    parser.parse
+    verify(parser)
+  end
+
+  def test_file_no_callbacks
+    parser = XML::SaxParser.file(saxtest_file)
+    assert_equal true, parser.parse
+  end
+
+  def test_noexistent_file
+    error = assert_raises(XML::Error) do
+      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
+      XML::SaxParser.file(nil)
+    end
+
+    assert_match(/nil into String/, error.to_s)
+  end
+
+  def test_io
+    File.open(saxtest_file) do |file|
+      parser = XML::SaxParser.io(file)
+      parser.callbacks = TestCaseCallbacks.new
+      parser.parse
+      verify(parser)
+    end
+  end
+
+  def test_nil_io
+    error = assert_raises(TypeError) do
+      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 = XML::SaxParser.string(xml)
+    assert_equal true, parser.parse
+  end
+
+  def test_string
+    xml = File.read(saxtest_file)
+    parser = 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 = XML::SaxParser.io(io)
+    
+    parser.callbacks = TestCaseCallbacks.new
+    parser.parse
+    verify(parser)
+  end
+
+  def test_nil_string
+    error = assert_raises(TypeError) do
+      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 = 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 = 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 = XML::SaxParser.string(xml)
+    parser.callbacks = TestCaseCallbacks.new
+
+    error = assert_raises(XML::Error) do
+      doc = parser.parse
+    end
+
+    # Check callbacks
+    result = parser.callbacks.result
+
+    i = -1
+    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: Premature end of data in tag Results line 1 at :2.", result[i+=1])
+    assert_equal("end_document", result[i+=1])
+
+    refute_nil(error)
+    assert_kind_of(XML::Error, error)
+    assert_equal("Fatal error: Premature end of data in tag Results line 1 at :2.", error.message)
+    assert_equal(XML::Error::PARSER, error.domain)
+    assert_equal(XML::Error::TAG_NOT_FINISHED, error.code)
+    assert_equal(XML::Error::FATAL, error.level)
+    assert_nil(error.file)
+    assert_equal(2, error.line)
+    assert_equal('Results', error.str1)
+    assert_nil(error.str2)
+    assert_nil(error.str3)
+    assert_equal(1, 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 = XML::SaxParser.string(xml)
+    parser.callbacks = TestCaseCallbacks.new
+
+    error = assert_raises(XML::Error) do
+      parser.parse
+    end
+    assert_equal("Fatal error: xmlParseEntityRef: no name at :5.", error.to_s)
+
+    # Check callbacks
+    result = parser.callbacks.result
+  end
+end

data/test/tc_schema.rb

@@ -0,0 +1,161 @@
+# encoding: UTF-8
+
+require './test_helper'
+
+class TestSchema < Minitest::Test
+  def setup
+    file = File.join(File.dirname(__FILE__), 'model/shiporder.xml')
+    @doc = XML::Document.file(file)
+  end
+
+  def teardown
+    @doc = nil
+  end
+
+  def schema
+    document = XML::Document.file(File.join(File.dirname(__FILE__), 'model/shiporder.xsd'))
+    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(XML::Error, error)
+    assert_equal(XML::Error::SCHEMASV, error.domain)
+    assert_equal(XML::Error::SCHEMAV_ELEMENT_CONTENT, error.code)
+    assert_equal(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(XML::Schema, schema)
+  end
+
+  def test_doc_valid
+    assert(@doc.validate_schema(schema))
+  end
+
+  def test_doc_invalid
+    new_node = XML::Node.new('invalid', 'this will mess up validation')
+    @doc.root << new_node
+
+    error = assert_raises(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 = 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
+    XML::Error.set_handler do |error|
+      errors << error
+    end
+
+    new_node = XML::Node.new('invalid', 'this will mess up validation')
+    @doc.root << new_node
+    reader = 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
+    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(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(XML::Schema::Type, schema.types['shiporder'])
+  end
+
+  def test_schema_type
+    type = schema.types['shiporder']
+
+    assert_equal('shiporder', type.name)
+    assert_equal(nil, type.namespace)
+    assert_equal("Shiporder type documentation", type.annotation)
+    assert_instance_of(XML::Node, type.node)
+    assert_equal(XML::Schema::Types::XML_SCHEMA_TYPE_COMPLEX, type.kind)
+    assert_instance_of(XML::Schema::Type, type.base)
+    assert_equal("anyType", type.base.name)
+    assert_equal(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_equal(nil, element.namespace)
+    assert_equal("orderperson element documentation", element.annotation)
+    assert_equal(1, element.min_occurs)
+    assert_equal(1, element.max_occurs)
+
+
+    element = schema.types['shiporder'].elements['item']
+    assert_equal(Float::INFINITY, element.max_occurs)
+
+    element = schema.types['shiporder'].elements['item'].type.elements['note']
+    assert_equal(0, element.min_occurs)
+    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(XML::Schema::Attribute, type.attributes.first)
+  end
+
+  def test_schema_attribute
+    attribute = schema.types['shiporder'].attributes.first
+
+    assert_equal("orderid", attribute.name)
+    assert_equal(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