smile-xml 1.0.0-jruby → 1.0.2-jruby

data/src/test/ruby/tc_parser.rb

@@ -0,0 +1,371 @@
+# encoding: UTF-8
+
+require './test_helper'
+require 'test/unit'
+require 'stringio'
+
+class TestParser < Test::Unit::TestCase
+  def setup
+    XML::Error.set_handler(&XML::Error::QUIET_HANDLER)
+  end
+
+  def teardown
+    GC.start
+    GC.start
+    GC.start
+    XML::Error.reset_handler()
+  end
+      
+  # -----  Sources  -------
+  def test_document
+    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/bands.utf-8.xml'))
+    parser = XML::Parser.file(file)
+    doc = parser.parse
+
+    parser = XML::Parser.document(doc)
+
+    doc = parser.parse
+
+    assert_instance_of(XML::Document, doc)
+    assert_instance_of(XML::Parser::Context, parser.context)
+  end
+
+  def test_nil_document
+    error = assert_raise(TypeError) do
+      XML::Parser.document(nil)
+    end
+
+    assert_equal("Must pass an XML::Document object", error.to_s)
+  end
+
+  def test_file
+    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
+
+    parser = XML::Parser.file(file)
+    doc = parser.parse
+    assert_instance_of(XML::Document, doc)
+    assert_instance_of(XML::Parser::Context, parser.context)
+  end
+
+  def test_noexistent_file
+    error = assert_raise(XML::Error) do
+      XML::Parser.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_raise(TypeError) do
+      XML::Parser.file(nil)
+    end
+
+    assert_equal("can't convert nil into String", error.to_s)
+  end
+
+  def test_file_encoding
+    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/bands.utf-8.xml'))
+    parser = XML::Parser.file(file, :encoding => XML::Encoding::ISO_8859_1)
+
+    puts "TODO #{__FILE__} #{__LINE__}"
+#    error = assert_raise(XML::Error) do
+#      doc = parser.parse
+#    end
+#
+#    assert(error.to_s.match(/Fatal error: Extra content at the end of the document/))
+#
+#    parser = XML::Parser.file(file, :encoding => XML::Encoding::UTF_8)
+#    doc = parser.parse
+#    assert_not_nil(doc)
+  end
+
+  def test_file_base_uri
+    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/bands.utf-8.xml'))
+
+    parser = XML::Parser.file(file)
+    doc = parser.parse
+    assert(doc.child.base_uri.match(/test\/ruby\/model\/bands.utf-8.xml/))
+
+    parser = XML::Parser.file(file, :base_uri => "http://libxml.org")
+    doc = parser.parse
+    assert(doc.child.base_uri.match(/test\/ruby\/model\/bands.utf-8.xml/))
+  end
+
+  def test_io
+    File.open(File.join(File.dirname(__FILE__), 'model/rubynet.xml')) do |io|
+      parser = XML::Parser.io(io)
+      assert_instance_of(XML::Parser, parser)
+
+      doc = parser.parse
+      assert_instance_of(XML::Document, doc)
+      assert_instance_of(XML::Parser::Context, parser.context)
+    end
+  end
+
+  def test_io_gc
+    # Test that the reader keeps a reference
+    # to the io object
+    file = File.open(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
+    parser = XML::Parser.io(file)
+    file = nil
+    GC.start
+    assert(parser.parse)
+  end
+
+  def test_nil_io
+    error = assert_raise(TypeError) do
+      XML::Parser.io(nil)
+    end
+
+    assert_equal("Must pass in an IO object", error.to_s)
+  end
+
+  def test_string_io
+    data = File.read(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
+    string_io = StringIO.new(data)
+    parser = XML::Parser.io(string_io)
+
+    doc = parser.parse
+    assert_instance_of(XML::Document, doc)
+    assert_instance_of(XML::Parser::Context, parser.context)
+  end
+
+  def test_string_io_thread
+    thread = Thread.new do
+      data = File.read(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
+      string_io = StringIO.new(data)
+      parser = XML::Parser.io(string_io)
+
+      doc = parser.parse
+      assert_instance_of(XML::Document, doc)
+      assert_instance_of(XML::Parser::Context, parser.context)
+    end
+
+    thread.join
+    assert(true)
+  end
+  
+  def test_string
+    str = '<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
+
+    parser = XML::Parser.string(str)
+    assert_instance_of(XML::Parser, parser)
+
+    doc = parser.parse
+    assert_instance_of(XML::Document, doc)
+    assert_instance_of(XML::Parser::Context, parser.context)
+  end
+
+  def test_nil_string
+    error = assert_raise(TypeError) do
+      XML::Parser.string(nil)
+    end
+
+    assert_equal("wrong argument type nil (expected String)", error.to_s)
+  end
+
+  def test_string_options
+    xml = <<-EOS
+      <!DOCTYPE foo [<!ENTITY foo 'bar'>]>
+      <test>
+        <cdata><![CDATA[something]]></cdata>
+        <entity>&foo;</entity>
+      </test>
+    EOS
+
+    XML::default_substitute_entities = false
+
+    # Parse normally
+    parser = XML::Parser.string(xml)
+    doc = parser.parse
+    assert_nil(doc.child.base_uri)
+
+    # Cdata section should be cdata nodes
+    node = doc.find_first('/test/cdata').child
+    assert_equal(XML::Node::CDATA_SECTION_NODE, node.node_type)
+
+    # Entities should not be subtituted
+    node = doc.find_first('/test/entity')
+    puts "TODO #{__FILE__} #{__LINE__}"
+    #assert_equal('&foo;', node.child.to_s)
+
+    # Parse with options
+    parser = XML::Parser.string(xml, :base_uri => 'http://libxml.rubyforge.org',
+                                     :options => XML::Parser::Options::NOCDATA | XML::Parser::Options::NOENT)
+    doc = parser.parse
+    puts "TODO #{__FILE__} #{__LINE__}"
+    #assert_equal( 'http://libxml.rubyforge.org', doc.child.base_uri)
+
+    # Cdata section should be text nodes
+    node = doc.find_first('/test/cdata').child
+    puts "TODO #{__FILE__} #{__LINE__}"
+    #assert_equal(XML::Node::TEXT_NODE, node.node_type)
+
+    # Entities should be subtituted
+    node = doc.find_first('/test/entity')
+    puts "TODO #{__FILE__} #{__LINE__}"
+    #assert_equal('bar', node.child.to_s)
+  end
+#
+  def test_string_encoding
+    # ISO_8859_1:
+    # ö - f6 in hex, \366 in octal
+    # ü - fc in hex, \374 in octal
+
+    xml = <<-EOS
+      <bands>
+        <metal>m\366tley_cr\374e</metal>
+      </bands>
+    EOS
+
+    # Parse as UTF_8
+    parser = XML::Parser.string(xml, :encoding => XML::Encoding::UTF_8)
+
+    puts "TODO #{__FILE__} #{__LINE__}"
+#    error = assert_raise(XML::Error) do
+#      doc = parser.parse
+#    end
+#
+#    assert_equal("Fatal error: Input is not proper UTF-8, indicate encoding !\nBytes: 0xF6 0x74 0x6C 0x65 at :2.",
+#                 error.to_s)
+
+    # Parse as ISO_8859_1:
+    parser = XML::Parser.string(xml, :encoding => XML::Encoding::ISO_8859_1)
+    doc = parser.parse
+    node = doc.find_first('//metal')
+    if defined?(Encoding)
+      assert_equal(Encoding::ISO8859_1, node.content.encoding)
+      assert_equal("m\303\266tley_cr\303\274e".force_encoding(Encoding::ISO8859_1), node.content)
+    else
+      puts "TODO #{__FILE__} #{__LINE__}"
+      #assert_equal("m\303\266tley_cr\303\274e", node.content)
+    end
+  end
+
+  def test_fd_gc
+    # Test opening # of documents up to the file limit for the OS.
+    # Ideally it should run until libxml emits a warning,
+    # thereby knowing we've done a GC sweep. For the time being,
+    # re-open the same doc `limit descriptors` times.
+    # If we make it to the end, then we've succeeded,
+    # otherwise an exception will be thrown.
+    XML::Error.set_handler {|error|}
+
+    max_fd = if RUBY_PLATFORM.match(/mswin32|mingw/i)
+      500
+    else
+      (`ulimit -n`.chomp.to_i) + 1
+    end
+
+    file = File.join(File.dirname(__FILE__), 'model/rubynet.xml')
+    max_fd.times do
+       XML::Parser.file(file).parse
+    end
+    XML::Error.reset_handler {|error|}
+  end
+
+
+  # -----  Errors  ------
+  def test_error
+    error = assert_raise(XML::Error) do
+      XML::Parser.string('<foo><bar/></foz>').parse
+    end
+
+    assert_not_nil(error)
+    assert_kind_of(XML::Error, error)
+    puts "TODO #{__FILE__} #{__LINE__}"
+    #assert_equal("Fatal error: Opening and ending tag mismatch: foo line 1 and foz at :1.", error.message)
+    assert_equal(XML::Error::PARSER, error.domain)
+    assert_equal(XML::Error::TAG_NAME_MISMATCH, error.code)
+    assert_equal(XML::Error::FATAL, error.level)
+    assert_nil(error.file)
+    puts "TODO #{__FILE__} #{__LINE__}"
+    #assert_equal(1, error.line)
+    puts "TODO #{__FILE__} #{__LINE__}"
+    #assert_equal('foo', error.str1)
+    puts "TODO #{__FILE__} #{__LINE__}"
+    #assert_equal('foz', error.str2)
+    assert_nil(error.str3)
+    puts "TODO #{__FILE__} #{__LINE__}"
+    #assert_equal(1, error.int1)
+    puts "TODO #{__FILE__} #{__LINE__}"
+    #assert_equal(20, error.int2)
+    assert_nil(error.node)
+  end
+
+  def test_bad_xml
+    parser = XML::Parser.string('<ruby_array uga="booga" foo="bar"<fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>')
+    error = assert_raise(XML::Error) do
+      assert_not_nil(parser.parse)
+    end
+
+    assert_not_nil(error)
+    assert_kind_of(XML::Error, error)
+    puts "TODO #{__FILE__} #{__LINE__}"
+    #assert_equal("Fatal error: Extra content at the end of the document at :1.", error.message)
+    assert_equal(XML::Error::PARSER, error.domain)
+    assert_equal(XML::Error::DOCUMENT_END, error.code)
+    assert_equal(XML::Error::FATAL, error.level)
+    assert_nil(error.file)
+    
+    puts "TODO #{__FILE__} #{__LINE__}"
+    #assert_equal(1, error.line)
+    assert_nil(error.str1)
+    assert_nil(error.str2)
+    assert_nil(error.str3)
+    puts "TODO #{__FILE__} #{__LINE__}"
+    #assert_equal(0, error.int1)
+    puts "TODO #{__FILE__} #{__LINE__}"
+    #assert_equal(20, error.int2)
+    assert_nil(error.node)
+  end
+
+  # Deprecated methods
+  def test_document_deprecated
+    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/bands.utf-8.xml'))
+    parser = XML::Parser.file(file)
+    doc = parser.parse
+
+    parser = XML::Parser.new
+    parser.document = doc
+    doc = parser.parse
+
+    assert_instance_of(XML::Document, doc)
+    assert_instance_of(XML::Parser::Context, parser.context)
+  end
+
+  def test_file_deprecated
+    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
+
+    parser = XML::Parser.new
+    parser.file = file
+    puts "TODO #{__FILE__} #{__LINE__}"
+    #doc = parser.parse
+    #assert_instance_of(XML::Document, doc)
+    #assert_instance_of(XML::Parser::Context, parser.context)
+  end
+
+  def test_io_deprecated
+    File.open(File.join(File.dirname(__FILE__), 'model/rubynet.xml')) do |io|
+      parser = XML::Parser.new
+      assert_instance_of(XML::Parser, parser)
+      parser.io = io
+
+      doc = parser.parse
+      assert_instance_of(XML::Document, doc)
+      assert_instance_of(XML::Parser::Context, parser.context)
+    end
+  end
+
+  def test_string_deprecated
+    str = '<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
+
+    parser = XML::Parser.new
+    parser.string = str
+    assert_instance_of(XML::Parser, parser)
+
+    doc = parser.parse
+    assert_instance_of(XML::Document, doc)
+    assert_instance_of(XML::Parser::Context, parser.context)
+  end
+end

data/src/test/ruby/tc_parser_context.rb

@@ -0,0 +1,189 @@
+# encoding: UTF-8
+
+require './test_helper'
+
+require 'test/unit'
+
+class TestParserContext < Test::Unit::TestCase
+  def test_string
+    # UTF8
+    xml = <<-EOS
+      <bands>
+        <metal>m\303\266tley_cr\303\274e</metal>
+      </bands>
+    EOS
+
+    context = XML::Parser::Context.string(xml)
+    assert_instance_of(XML::Parser::Context, context)
+    assert_equal(XML::Encoding::NONE, context.encoding)
+    assert_nil(context.base_uri)
+  end
+
+  def test_encoding
+    # ISO_8859_1:
+    xml = <<-EOS
+      <bands>
+        <metal>m\366tley_cr\374e</metal>
+      </bands>
+    EOS
+
+    context = XML::Parser::Context.string(xml)
+    assert_equal(XML::Encoding::NONE, context.encoding)
+
+    context.encoding = XML::Encoding::ISO_8859_1
+    assert_equal(XML::Encoding::ISO_8859_1, context.encoding)
+  end
+
+  def test_base_uri
+    # UTF8
+    xml = <<-EOS
+      <bands>
+        <metal>m\303\266tley_cr\303\274e</metal>
+      </bands>
+    EOS
+
+    context = XML::Parser::Context.string(xml)
+    assert_nil(context.base_uri)
+
+    context.base_uri = 'http://libxml.rubyforge.org'
+    assert_equal('http://libxml.rubyforge.org', context.base_uri)
+  end
+
+  def test_string_empty
+    error = assert_raise(TypeError) do
+      parser = XML::Parser::Context.string(nil)
+    end
+    assert_equal("wrong argument type nil (expected String)", error.to_s)
+
+    error = assert_raise(ArgumentError) do
+      XML::Parser::Context.string('')
+    end
+    assert_equal("Must specify a string with one or more characters", error.to_s)
+  end
+
+  def test_well_formed
+    parser = XML::Parser.string("<abc/>")
+    parser.parse
+    assert(parser.context.well_formed?)
+  end
+
+  def test_not_well_formed
+    parser = XML::Parser.string("<abc>")
+    assert_raise(XML::Error) do
+      parser.parse
+    end
+    assert(!parser.context.well_formed?)
+  end
+
+  def test_version_info
+    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/bands.utf-8.xml'))
+    parser = XML::Parser.file(file)
+    assert_nil(parser.context.version)
+    parser.parse
+    assert_equal("1.0", parser.context.version)
+  end
+
+  def test_depth
+    context = XML::Parser::Context.new
+    assert_instance_of(Fixnum, context.depth)
+  end
+
+  def test_disable_sax
+    context = XML::Parser::Context.new
+    assert(!context.disable_sax?)
+  end
+
+  def test_docbook
+    context = XML::Parser::Context.new
+    assert(!context.docbook?)
+  end
+
+  def test_html
+    context = XML::Parser::Context.new
+    assert(!context.html?)
+  end
+
+  def test_keep_blanks
+    context = XML::Parser::Context.new
+    if context.keep_blanks?
+      assert_instance_of(TrueClass, context.keep_blanks?)
+    else
+      assert_instance_of(FalseClass, context.keep_blanks?)
+    end
+  end
+
+  if ENV['NOTWORKING']
+    def test_num_chars
+      assert_equal(17, context.num_chars)
+    end
+  end
+
+  def test_replace_entities
+    context = XML::Parser::Context.new
+    assert(!context.replace_entities?)
+
+#    context.options = 1
+ #   assert(context.replace_entities?)
+
+    context.options = 0
+    assert(!context.replace_entities?)
+
+    context.replace_entities = true
+    assert(context.replace_entities?)
+  end
+
+  def test_space_depth
+    context = XML::Parser::Context.new
+    assert_equal(1, context.space_depth)
+  end
+
+  def test_subset_external
+    context = XML::Parser::Context.new
+    assert(!context.subset_external?)
+  end
+
+  def test_data_directory_get
+    context = XML::Parser::Context.new
+    assert_nil(context.data_directory)
+  end
+
+  def test_parse_error
+    xp = XML::Parser.string('<foo><bar/></foz>')
+
+    assert_raise(XML::Error) do
+      xp.parse
+    end
+
+    # Now check context
+    context = xp.context
+    assert_equal(nil, context.data_directory)
+    assert_equal(0, context.depth)
+    assert_equal(true, context.disable_sax?)
+    assert_equal(false, context.docbook?)
+    assert_equal(XML::Encoding::NONE, context.encoding)
+    assert_equal(76, context.errno)
+    assert_equal(false, context.html?)
+    assert_equal(5, context.io_max_num_streams)
+    assert_equal(1, context.io_num_streams)
+    assert_equal(true, context.keep_blanks?)
+    assert_equal(1, context.io_num_streams)
+    assert_equal(nil, context.name_node)
+    assert_equal(0, context.name_depth)
+    assert_equal(10, context.name_depth_max)
+    assert_equal(17, context.num_chars)
+    assert_equal(false, context.replace_entities?)
+    assert_equal(1, context.space_depth)
+    assert_equal(10, context.space_depth_max)
+    assert_equal(false, context.subset_external?)
+    assert_equal(nil, context.subset_external_system_id)
+    assert_equal(nil, context.subset_external_uri)
+    assert_equal(false, context.subset_internal?)
+    assert_equal(nil, context.subset_internal_name)
+    assert_equal(false, context.stats?)
+    assert_equal(true, context.standalone?)
+    assert_equal(false, context.valid)
+    assert_equal(false, context.validate?)
+    assert_equal('1.0', context.version)
+    assert_equal(false, context.well_formed?)
+  end
+end

data/src/test/ruby/tc_properties.rb

@@ -0,0 +1,40 @@
+# encoding: UTF-8
+
+require './test_helper'
+
+require 'test/unit'
+
+# attributes is deprecated - use attributes instead.
+# Tests for backwards compatibility
+
+class Testattributes < Test::Unit::TestCase
+  def setup()
+    xp = XML::Parser.string('<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>')
+    @doc = xp.parse
+  end
+
+  def teardown()
+    @doc = nil
+  end
+
+  def test_traversal
+    attributes = @doc.root.attributes
+    
+    assert_instance_of(XML::Attributes, attributes)
+    f = attributes.first
+    l = f.next
+    assert( f.name.eql?( 'uga' ) || f.name.eql?( 'foo' ) )
+    assert( l.name.eql?( 'uga' ) || l.name.eql?( 'foo' ) )
+
+    n = f.next
+    assert_instance_of(XML::Attr, n)
+    assert( n.name.eql?( 'uga' ) || n.name.eql?( 'foo' ) )
+
+  end
+  
+  def test_no_attributes
+    attributes = @doc.root.child.attributes
+    assert_instance_of(XML::Attributes, attributes)
+    assert_equal(0, attributes.length)
+  end
+end