libxml-ruby 2.8.0 → 3.2.3

data/test/tc_reader.rb

@@ -1,400 +0,0 @@
-# encoding: UTF-8
-
-require './test_helper'
-require 'stringio'
-require 'test/unit'
-
-class TestReader < Test::Unit::TestCase
-  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 = [XML::Reader::TYPE_PROCESSING_INSTRUCTION,
-                XML::Reader::TYPE_ELEMENT,
-                XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
-                XML::Reader::TYPE_COMMENT,
-                XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
-                XML::Reader::TYPE_ELEMENT,
-                XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
-                XML::Reader::TYPE_ELEMENT,
-                XML::Reader::TYPE_CDATA,
-                XML::Reader::TYPE_END_ELEMENT,
-                XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
-                XML::Reader::TYPE_ELEMENT,
-                XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
-                XML::Reader::TYPE_ELEMENT,
-                XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
-                XML::Reader::TYPE_ELEMENT,
-                XML::Reader::TYPE_TEXT,
-                XML::Reader::TYPE_END_ELEMENT,
-                XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
-                XML::Reader::TYPE_END_ELEMENT,
-                XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
-                XML::Reader::TYPE_END_ELEMENT,
-                XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
-                XML::Reader::TYPE_END_ELEMENT,
-                XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
-                XML::Reader::TYPE_END_ELEMENT]
-
-    assert_equal(expected, node_types)
-  end
-
-  def test_document
-    reader = XML::Reader.document(XML::Document.file(XML_FILE))
-    verify_simple(reader)
-  end
-
-  def test_file
-    reader = XML::Reader.file(XML_FILE)
-    verify_simple(reader)
-  end
-
-  def test_invalid_file
-    assert_raise(XML::Error) do
-      XML::Reader.file('/does/not/exist')
-    end
-  end
-
-  def test_string
-    reader = XML::Reader.string(File.read(XML_FILE))
-    verify_simple(reader)
-  end
-
-  def test_io
-    File.open(XML_FILE, 'rb') do |io|
-      reader = 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 = 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 = XML::Reader.io(string_io)
-    verify_simple(reader)
-  end
-
-  def test_error
-    reader = XML::Reader.string('<foo blah')
-
-    error = assert_raise(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_deprecated_error_handler
-    called = false
-    reader = XML::Reader.string('<foo blah')
-    reader.set_error_handler do |error|
-      called = true
-    end
-
-    assert_raise(XML::Error) do
-      reader.read
-    end
-
-    assert(called)
-  end
-
-  def test_deprecated_reset_error_handler
-    called = false
-    reader = XML::Reader.string('<foo blah')
-    reader.set_error_handler do |error|
-      called = true
-    end
-    reader.reset_error_handler
-
-    assert_raise(XML::Error) do
-      reader.read
-    end
-
-    assert(!called)
-  end
-
-  def test_attr
-    parser = 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_equal(nil, parser['z'])
-    assert_equal(nil, parser[2])
-  end
-
-  def test_move_to_attribute_depreciation
-    previous_stderr, $stderr = $stderr, StringIO.new
-    reader = XML::Reader.string("<foo x='1' y='2'/>")
-    assert(reader.read)
-    assert(reader.move_to_attribute 1)
-    assert($stderr.string =~ /deprecated/)
-  ensure
-    $stderr = previous_stderr
-  end
-
-  def test_move_attr
-      reader = 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 = 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_equal(reader.get_attribute_no(12), nil)
-      assert_equal(reader.get_attribute('baz'), nil)
-      assert_equal(reader.get_attribute_ns('baz', 'http://ruby/namespace'), nil)
-  end
-
-  def test_value
-    parser = XML::Reader.string("<foo><bar>1</bar><bar>2</bar><bar>3</bar></foo>")
-    assert(parser.read)
-    assert_equal('foo', parser.name)
-    assert_equal(nil, parser.value)
-    3.times do |i|
-      assert(parser.read)
-      assert_equal(XML::Reader::TYPE_ELEMENT, parser.node_type)
-      assert_equal('bar', parser.name)
-      assert(parser.read)
-      assert_equal(XML::Reader::TYPE_TEXT, parser.node_type)
-      assert_equal((i + 1).to_s, parser.value)
-      assert(parser.read)
-      assert_equal(XML::Reader::TYPE_END_ELEMENT, parser.node_type)
-    end
-  end
-
-  def test_expand
-    reader = XML::Reader.file(XML_FILE)
-    reader.read.to_s
-    reader.read
-
-    # Read a node
-    node = reader.expand
-    assert_equal('feed', node.name)
-    assert_equal(::Encoding::UTF_8, node.name.encoding) if defined?(::Encoding)
-  end
-
-  def test_expand_doc
-    reader = XML::Reader.file(XML_FILE)
-    reader.read.to_s
-    reader.read
-
-    # Read a node
-    node = reader.expand
-
-    # Try to access the document
-    assert_not_nil(node.doc)
-  end
-
-  def test_expand_find
-    reader = XML::Reader.file(XML_FILE)
-    reader.read.to_s
-    reader.read
-
-    # Read first node which
-    node = reader.expand
-    assert_equal('feed', node.name)
-
-    # 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 = XML::Reader.file(XML_FILE)
-
-    # Expand a node before one has been read
-    error = assert_raise(RuntimeError) do
-      reader.expand
-    end
-    assert_equal("The reader does not have a document.  Did you forget to call read?", error.to_s)
-  end
-
-  def test_expand_invalid_access
-    reader = XML::Reader.file(XML_FILE)
-
-    # Read a node
-    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
-    error = assert_raise(RuntimeError) do
-      assert_equal('feed', node.name)
-    end
-    assert_equal("This node has already been freed.", error.to_s)
-  end
-
-  def test_mode
-    reader = XML::Reader.string('<xml/>')
-    assert_equal(XML::Reader::MODE_INITIAL, reader.read_state)
-    reader.read
-    assert_equal(XML::Reader::MODE_EOF, reader.read_state)
-  end
-
-  def test_bytes_consumed
-    reader = XML::Reader.file(XML_FILE)
-    reader.read
-    assert_equal(416, reader.byte_consumed)
-  end
-
-  def test_node
-    XML.default_line_numbers = true
-    reader = XML::Reader.file(XML_FILE)
-
-    # first try to get a node
-    assert_nil(reader.node)
-
-    reader.read
-    assert_instance_of(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 = 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 = XML::Reader.string(xml)
-    reader.read # foo
-    reader.read # test
-    reader.read # text
-    reader.read # cdata
-    reader.read # cdata-section
-    assert_equal(XML::Node::CDATA_SECTION_NODE, reader.node_type)
-
-    # Convert cdata section to text
-    reader = XML::Reader.string(xml, :options => XML::Parser::Options::NOCDATA)
-    reader.read # foo
-    reader.read # test
-    reader.read # text
-    reader.read # cdata
-    reader.read # cdata-section
-    assert_equal(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 = XML::Reader.string(xml, :encoding => XML::Encoding::ISO_8859_1)
-    reader.read
-
-    if defined?(Encoding)
-      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)
-    else
-      assert_equal("<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.read_outer_xml)
-    end
-  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 = XML::Reader.string(xml)
-    error = assert_raise(XML::Error) do
-      node = 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 = XML::Reader.file(XML_FILE)
-    reader.read
-    assert_equal(XML::Encoding::UTF_8, reader.encoding)
-    assert_equal(Encoding::UTF_8, reader.value.encoding) if defined?(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 = XML::Reader.string(xml, :encoding => XML::Encoding::ISO_8859_1)
-    reader.read
-
-    # Encoding is always null for strings, very annoying!
-    assert_equal(reader.encoding, XML::Encoding::NONE)
-  end
-end

data/test/tc_relaxng.rb

@@ -1,54 +0,0 @@
-# encoding: UTF-8
-
-require './test_helper'
-
-require 'test/unit'
-
-class TestRelaxNG < Test::Unit::TestCase
-  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_raise(XML::Error) do
-      @doc.validate_relaxng(relaxng)
-    end
-
-    assert_not_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)
-    assert_not_nil(error.node)
-    assert_equal('invalid', error.node.name)
-  end
-end

data/test/tc_schema.rb

@@ -1,162 +0,0 @@
-# encoding: UTF-8
-
-require './test_helper'
-require 'test/unit'
-
-class TestSchema < Test::Unit::TestCase
-  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)
-    assert_not_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_raise(XML::Error) do
-      @doc.validate_schema(schema)
-    end
-
-    check_error(error)
-    assert_nil(error.line)
-    assert_not_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