libxml-fixed-jruby 1.0.0-jruby

data/test/tc_node_text.rb

@@ -0,0 +1,17 @@
+require 'xml'
+require 'test/unit'
+
+class TC_XML_Node_text < Test::Unit::TestCase
+  def setup
+    @t=XML::Node.new_text("testdata")
+    assert_instance_of(XML::Node,@t)
+  end
+
+  def test_content
+    assert_equal("testdata",@t.content)
+  end
+
+  def test_type
+    assert_equal(true,@t.text?)
+  end
+end

data/test/tc_node_xlink.rb

@@ -0,0 +1,28 @@
+# $Id$
+require "xml"
+require 'test/unit'
+
+class TC_XML_Node_XLink < Test::Unit::TestCase
+  def setup()
+    xp = XML::Parser.new()
+    str = '<ruby_array xmlns:xlink="http://www.w3.org/1999/xlink/namespace/"><fixnum xlink:type="simple">one</fixnum></ruby_array>'
+    assert_equal(str, xp.string = str)
+    doc = xp.parse
+    assert_instance_of(XML::Document, doc)
+    @root = doc.root
+    assert_instance_of(XML::Node, @root)
+  end
+
+  def teardown()
+    @root = nil
+  end
+
+  def test_xml_node_xlink()
+    for elem in @root.find('fixnum')
+      assert_instance_of(XML::Node, elem)
+      assert_instance_of(TrueClass, elem.xlink?)
+      assert_equal("simple", elem.xlink_type_name)
+      assert_equal(XML::Node::XLINK_TYPE_SIMPLE, elem.xlink_type)
+    end
+  end
+end

data/test/tc_ns.rb

@@ -0,0 +1,18 @@
+require "xml"
+require 'test/unit'
+
+class TestNS < Test::Unit::TestCase
+  def test_ns
+    node = XML::Node.new('foo')
+    ns = XML::NS.new(node, 'http://www.mynamespace.com', 'my_namepace')
+    assert_equal(ns.prefix, 'my_namepace')
+    assert_equal(ns.href, 'http://www.mynamespace.com')
+  end
+  
+  def test_default_ns
+    node = XML::Node.new('foo')
+    ns = XML::NS.new(node, 'http://www.mynamespace.com', nil)
+    assert_equal(ns.prefix, nil)
+    assert_equal(ns.href, 'http://www.mynamespace.com')
+  end
+end

data/test/tc_parser.rb

@@ -0,0 +1,308 @@
+require "xml"
+require 'test/unit'
+require 'test_helper'
+
+class TestParser < Test::Unit::TestCase
+  def setup
+    XML::Parser.register_error_handler(nil)
+    @xp = XML::Parser.new
+  end
+
+  def teardown
+    @xp = nil
+    XML::Parser.register_error_handler(nil)
+    # Clear out all the files we opened up in
+    # the test_fd_gc test
+    GC.start
+  end
+      
+  # -----  Constants  ------
+  def test_lib_versions
+    assert(XML::Parser::check_lib_versions)
+  end
+
+  def test_debug_entities
+    XML::Parser::debug_entities = false
+    assert(!XML::Parser::debug_entities)
+
+    XML::Parser::debug_entities = true
+    assert(XML::Parser::debug_entities)
+
+    XML::Parser::debug_entities = false
+    assert(!XML::Parser::debug_entities)
+  end
+
+  def test_default_compression
+    return unless XML::Parser::default_compression
+    
+    0.upto(9) do |i|
+      XML::Parser::default_compression = i
+      assert_equal(i, XML::Parser::default_compression)
+    end
+
+    9.downto(0) do |i|
+      assert_equal(i, XML::Parser::default_compression = i)
+      assert_equal(i, XML::Parser::default_compression)
+    end
+
+    0.downto(-10) do |i|
+      assert_equal(i, XML::Parser::default_compression = i)
+      assert_equal(0, XML::Parser::default_compression)
+    end
+
+    10.upto(20) do |i|
+      assert_equal(i, XML::Parser::default_compression = i)
+      assert_equal(9, XML::Parser::default_compression)
+    end
+  end
+
+  def test_default_keep_blanks
+    XML::Parser::default_keep_blanks = false
+    assert(!XML::Parser::default_keep_blanks)
+
+    XML::Parser::default_keep_blanks = true
+    assert(XML::Parser::default_keep_blanks)
+
+    XML::Parser::default_keep_blanks = false
+    assert(!XML::Parser::default_keep_blanks)
+
+    # other tests depend on keeping blanks by default,
+    # which is the default default behaviour anyway.
+    XML::Parser::default_keep_blanks = true
+  end
+
+  def test_default_line_numbers
+    XML::Parser::default_line_numbers = false
+    assert(!XML::Parser::default_line_numbers)
+
+    XML::Parser::default_line_numbers = true
+    assert(XML::Parser::default_line_numbers)
+
+    XML::Parser::default_line_numbers = false
+    assert(!XML::Parser::default_line_numbers)
+  end
+
+  def test_default_substitute_entities
+    XML::Parser::default_substitute_entities = false
+    assert(!XML::Parser::default_substitute_entities)
+
+    XML::Parser::default_substitute_entities = true
+    assert(XML::Parser::default_substitute_entities)
+
+    XML::Parser::default_substitute_entities = false
+    assert(!XML::Parser::default_substitute_entities)
+  end
+
+  def test_default_tree_indent_string
+    s = XML::Parser::default_tree_indent_string
+    assert_instance_of(String, s)
+    assert_equal('  ', s)
+    XML::Parser::default_tree_indent_string = 'uga'
+    s = XML::Parser::default_tree_indent_string
+    assert_instance_of(String, s)
+    assert_equal('uga', s)
+    XML::Parser::default_tree_indent_string = '  '
+    s = XML::Parser::default_tree_indent_string
+    assert_instance_of(String, s)
+    assert_equal('  ', s)
+  end
+
+  def test_default_validity_checking
+    XML::Parser::default_validity_checking = false
+    assert(!XML::Parser::default_validity_checking)
+
+    XML::Parser::default_validity_checking = true
+    assert(XML::Parser::default_validity_checking)
+
+    XML::Parser::default_validity_checking = false
+    assert(!XML::Parser::default_validity_checking)
+  end
+
+  def test_default_warnings
+    XML::Parser::default_warnings = false
+    assert(!XML::Parser::default_warnings)
+
+    XML::Parser::default_warnings = true
+    assert(XML::Parser::default_warnings)
+
+    XML::Parser::default_warnings = false
+    assert(!XML::Parser::default_warnings)
+  end
+
+  def test_intent_tree_output
+    assert(TrueClass, XML::Parser::indent_tree_output)
+
+    XML::Parser::indent_tree_output = false
+    assert(FalseClass, XML::Parser::indent_tree_output)
+
+    XML::Parser::indent_tree_output = true
+    assert(TrueClass, XML::Parser::indent_tree_output)
+  end
+
+  def test_version
+    assert_instance_of(String, XML::Parser::VERSION)
+  end
+
+  def test_vernum
+    assert_instance_of(Fixnum, XML::Parser::VERNUM)
+  end
+
+  # -----  IO  ------
+  def test_string
+    str = '<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
+    assert_equal(str, @xp.string = str)
+    assert_instance_of(XML::Document, @xp.parse)
+  end
+  
+  def test_context
+    @xp = XML::Parser.string('<rubynet><testing>uga</testing><uga>foo</uga></rubynet>')
+    doc = @xp.parse
+    assert_instance_of(XML::Document, doc)
+    # FIXME Parser#context is not implemented
+    # assert_instance_of(XML::Parser::Context, @xp.context)
+  end
+
+  def test_file
+    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
+    
+    @xp.filename = file
+    assert_equal(file, @xp.filename)
+    
+    doc = @xp.parse
+    assert_instance_of(XML::Document, doc)
+  end
+
+  def test_io
+    File.open(File.join(File.dirname(__FILE__), 'model/rubynet.xml')) do |f|
+      assert_kind_of(IO, f)
+      assert_kind_of(IO, @xp.io = f)
+      assert_instance_of(XML::Document, @xp.parse)
+    end
+  end
+
+  def test_string_io
+    data = File.read(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
+    string_io = StringIO.new(data)
+    assert_raises(TypeError) do
+      assert_kind_of(StringIO, @xp.io = string_io)
+    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.
+
+    # FIXME removed test, extremely slow...
+    # XML::Parser.register_error_handler(lambda {|msg| nil })
+    # 
+    # max_fd = if RUBY_PLATFORM.match(/mswin32/i)
+    #   500
+    # else
+    #   (`ulimit -n`.chomp.to_i) + 1
+    # end
+    # 
+    # filename = File.join(File.dirname(__FILE__), 'model/rubynet.xml')
+    # max_fd.times do
+    #    XML::Document.file(filename)
+    # end
+  end
+
+  def test_libxml_parser_features
+    assert_instance_of(Array, XML::Parser::features)
+  end
+
+  # -----  Errors  ------
+  def test_error_handler
+    assert_raise(XML::Parser::ParseError) do
+      XML::Parser.string('<foo><bar/></foz>').parse
+    end
+
+    ary = []
+    XML::Parser.register_error_handler do |msg|
+      ary << msg
+    end
+
+    # this will use our error handler
+    assert_raise(XML::Parser::ParseError) do
+      XML::Parser.string('<foo><bar/></foz>').parse
+    end
+    
+    # FIXME Errors are not the same across platforms
+    # assert_equal(["Entity: line 1: ",
+    #               "parser ",
+    #               "error : ",
+    #               "Opening and ending tag mismatch: foo line 1 and foz\n",
+    #               "<foo><bar/></foz>\n",
+    #               "                 ^\n"], ary)
+
+    # assert_instance_of(Proc, XML::Parser.register_error_handler(nil))
+
+    # this will go to stderr again
+    assert_raise(XML::Parser::ParseError) do
+      d = XML::Parser.string('<foo><bar/></foz>').parse
+    end
+  end
+  
+  def test_error_handler_lambda
+    XML::Parser.register_error_handler(nil)
+    assert_raise(XML::Parser::ParseError) do
+      XML::Parser.string('<foo><bar/></foz>').parse
+    end
+
+    ary = []
+    assert_nil XML::Parser.register_error_handler(lambda { |msg| ary << msg })
+
+    # this will use our error handler
+    assert_raise(XML::Parser::ParseError) do
+      XML::Parser.string('<foo><bar/></foz>').parse
+    end
+
+    # FIXME Errors are not the same across platforms
+    # assert_equal(["Entity: line 1: ",
+    #               "parser ",
+    #               "error : ",
+    #               "Opening and ending tag mismatch: foo line 1 and foz\n",
+    #               "<foo><bar/></foz>\n",
+    #               "                 ^\n"], ary)
+
+    # assert_instance_of(Proc, XML::Parser.register_error_handler(nil))
+
+    # this will go to stderr again
+    assert_raise(XML::Parser::ParseError) do
+      d = XML::Parser.string('<foo><bar/></foz>').parse
+    end
+  end
+  
+  def test_bad_xml
+    @xp.string = '<ruby_array uga="booga" foo="bar"<fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
+    XML::Parser.register_error_handler(lambda {|msg| nil })
+    assert_raise(XML::Parser::ParseError) do
+      assert_not_nil(@xp.parse)
+    end
+  end
+  
+  def test_double_parse
+    XML::Parser.register_error_handler(lambda {|msg| nil })
+    parser = XML::Parser.string("<test>something</test>")
+    doc = parser.parse
+    
+    assert_raise(XML::Parser::ParseError) do
+      parser.parse
+    end
+  end
+  
+  def test_libxml_parser_empty_string
+    assert_raise(XML::Parser::ParseError) do
+      @xp.string = ''
+      @xp.parse
+    end
+    
+    assert_raise(TypeError) do
+      @xp.string = nil
+    end
+  end
+end

data/test/tc_parser_context.rb

@@ -0,0 +1,126 @@
+require "xml"
+require 'test/unit'
+
+class TestParserContext < Test::Unit::TestCase
+  def setup
+    str = '<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
+    xp = XML::Parser.string(str)
+    assert_equal(str, xp.string = str)
+    doc = xp.parse
+    assert_instance_of(XML::Document, doc)
+    @ctxt = xp.context
+    assert_instance_of(XML::Parser::Context, @ctxt)
+  end
+
+  def teardown
+    @ctxt = nil
+  end
+
+  def test_well_formed
+    if @ctxt.well_formed?
+      assert_instance_of(TrueClass, @ctxt.well_formed?)
+    else
+      assert_instance_of(FalseClass, @ctxt.well_formed?)
+    end
+  end
+
+  def test_version_info
+    assert_instance_of(String, @ctxt.version)
+  end
+
+  def test_depth
+    assert_instance_of(Fixnum, @ctxt.depth)
+  end
+
+  def test_disable_sax
+    assert(!@ctxt.disable_sax?)
+  end
+
+  def test_docbook
+    assert(!@ctxt.docbook?)
+  end
+
+  def test_encoding
+    assert(!@ctxt.encoding)
+  end
+
+  def test_html
+    assert(!@ctxt.html?)
+  end
+
+  def test_keep_blanks
+    if @ctxt.keep_blanks?
+      assert_instance_of(TrueClass, @ctxt.keep_blanks?)
+    else
+      assert_instance_of(FalseClass, @ctxt.keep_blanks?)
+    end
+  end
+
+  if ENV['NOTWORKING']
+    def test_num_chars
+      assert_equal(17, @ctxt.num_chars)
+    end
+  end
+
+  def test_replace_entities
+    if @ctxt.replace_entities?
+      assert_instance_of(TrueClass, @ctxt.replace_entities?)
+    else
+      assert_instance_of(FalseClass, @ctxt.replace_entities?)
+    end
+  end
+
+  def test_space_depth
+    assert_equal(1, @ctxt.space_depth)
+  end
+
+  def test_subset_external
+    assert(!@ctxt.subset_external?)
+  end
+
+  def test_data_directory_get
+    assert_nil(@ctxt.data_directory)
+  end
+
+  def test_parse_error
+    xp = XML::Parser.new
+    xp.string = '<foo><bar/></foz>'
+    
+    assert_raise(XML::Parser::ParseError) 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(nil, 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(0, context.options)
+    assert_equal(true, 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