libxml-ruby 0.7.0-x86-mswin32-60 → 0.8.0-x86-mswin32-60

data/test/tc_xml_document_write.rb

@@ -2,23 +2,138 @@ require "libxml"
 require 'test/unit'
 
 class TC_XML_Document_Write < Test::Unit::TestCase
-  def setup()
+  def setup
     @doc = XML::Document.new('1.0')
-    assert_instance_of(XML::Document, @doc)
   end
 
-  def teardown()
+  def teardown
     @doc = nil
   end
 
-  def test_ruby_xml_document_write_initialize()
-    assert_instance_of(XML::Document, XML::Document.new())
+  def test_klass
+    assert_instance_of(XML::Document, @doc)
+  end
+
+  def test_version
     assert_equal('1.0', @doc.version)
-  end # def test_ruby_xml_document_initialize()
 
-  def test_ruby_xml_document_write_initialize2()
     doc = XML::Document.new('6.9')
-    assert_instance_of(XML::Document, doc)
     assert_equal('6.9', doc.version)
-  end # def test_ruby_xml_document_initialize2()
-end # TC_XML_Document_Write
+  end
+  
+  def test_write_root
+    @doc.root = XML::Node.new('rubynet')
+    assert_instance_of(XML::Node, @doc.root)
+    assert_instance_of(XML::Document, @doc.root.doc)
+    assert_equal("<?xml version=\"1.0\"?>\n<rubynet/>\n", @doc.to_s)
+  end
+
+  def test_write_root
+    @doc.root = XML::Node.new('rubynet')
+    assert_instance_of(XML::Node, @doc.root)
+    assert_instance_of(XML::Document, @doc.root.doc)
+    assert_equal("<?xml version=\"1.0\"?>\n<rubynet/>\n", @doc.to_s(false))
+  end
+
+  def test_encoding
+    @doc.root = XML::Node.new('rubynet')
+    @doc.encoding = 'UTF-8'
+    assert_instance_of(XML::Node, @doc.root)
+    assert_equal("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<rubynet/>\n", @doc.to_s)
+  end
+
+  def test_child()
+    xml = "<?xml version=\"1.0\"?>\n<rubynet>\n  <pkg/>\n</rubynet>\n"
+    @doc.root = XML::Node.new('rubynet')
+    @doc.root.child = XML::Node.new('pkg')
+    assert_equal(xml, @doc.to_s)
+  end
+
+  def test_append
+    xml = "<?xml version=\"1.0\"?>\n"
+    xml << "<rubynet>\n"
+    xml << "  <pkg>\n"
+    xml << "    <meta>\n"
+    xml << "      <pkgname>libxml</pkgname>\n"
+    xml << "    </meta>\n"
+    xml << "  </pkg>\n"
+    xml << "</rubynet>\n"
+    
+    @doc.root = XML::Node.new('rubynet')
+    pkg = @doc.root.child = XML::Node.new('pkg')
+    meta = pkg.child = XML::Node.new('meta')
+    assert_equal(meta, meta << (pkgname = XML::Node.new('pkgname')))
+    pkgname << 'libxml'
+    assert_equal(xml, @doc.to_s)
+  end
+
+  def test_node_search_href
+    prefix = 'xlink'
+    uri = 'http://www.rubynet.org'
+    xml = "<?xml version=\"1.0\"?>\n"
+    xml << "<rubynet xmlns:#{prefix}=\"#{uri}\">\n"
+    xml << "  <pkg/>\n"
+    xml << "</rubynet>\n"
+    
+    @doc.root = XML::Node.new('rubynet')
+    @doc = XML::Parser.string(xml).parse
+    assert_equal(xml, @doc.to_s)
+    ns = @doc.root.search_href(uri)
+    assert_instance_of(XML::NS, ns)
+    assert_equal(uri, ns.href)
+    assert_equal(prefix, ns.prefix)
+  end
+
+  def test_sibling
+    xml = "<?xml version=\"1.0\"?>\n<rubynet>\n  <pkg/>\n  <pkg2/>\n</rubynet>\n"
+
+    @doc.root = XML::Node.new('rubynet')
+    child = @doc.root.child = XML::Node.new('pkg')
+    assert_instance_of(XML::Node, child)
+    child.sibling = XML::Node.new('pkg2')
+    assert_equal(xml, @doc.to_s)
+  end
+
+  def test_set_doc_property
+    xml = "<?xml version=\"1.0\"?>\n"
+    xml << "<rubynet xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n"
+    xml << "  <pkg/>\n"
+    xml << "</rubynet>\n"
+    
+    @doc.root = XML::Node.new('rubynet')
+    @doc.root['xmlns:xlink'] = "http://www.w3.org/1999/xlink"
+    pkg = @doc.root.child = XML::Node.new('pkg')
+    assert_equal(xml, @doc.to_s)
+  end
+
+  def test_set_node_base
+    xml = "<?xml version=\"1.0\"?>\n"
+    xml << "<rubynet>\n"
+    xml << "  <pkg xml:base=\"http://www.rubynet.org/\"/>\n"
+    xml << "</rubynet>\n"
+    
+    @doc.root = XML::Node.new('rubynet')
+    pkg = @doc.root.child = XML::Node.new('pkg')
+    pkg.base = 'http://www.rubynet.org/'
+    assert_equal(xml, @doc.to_s)
+  end
+
+  def test_set_node_property
+    xml = "<?xml version=\"1.0\"?>\n"
+    xml << "<rubynet xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n"
+    xml << "  <pkg version=\"1.0\">\n"
+    xml << "    <meta>\n"
+    xml << "      <pkgname>libxml</pkgname>\n"
+    xml << "    </meta>\n"
+    xml << "  </pkg>\n"
+    xml << "</rubynet>\n"
+    
+    @doc.root = XML::Node.new('rubynet')
+    @doc.root['xmlns:xlink'] = "http://www.w3.org/1999/xlink"
+    pkg = @doc.root.child = XML::Node.new('pkg')
+    pkg['version'] = '1.0'
+    meta = pkg.child = XML::Node.new('meta')
+    pkgname = meta.child = XML::Node.new('pkgname', 'libxml')
+    assert_equal(xml, @doc.to_s)
+  end
+end

data/test/tc_xml_dtd.rb

@@ -46,4 +46,25 @@ class TestDtd < Test::Unit::TestCase
       
     assert_equal(expected, messages)
   end
-end
+  
+  def test_external_dtd
+    xml = <<-EOS
+      <!DOCTYPE test PUBLIC "-//TEST" "test.dtd" []>
+      <test>
+        <title>T1</title>
+      </test>
+    EOS
+    
+    messages = Array.new
+    XML::Parser.register_error_handler(lambda { |msg| messages << msg })
+    
+    XML::Parser.default_load_external_dtd = false
+    doc = XML::Parser.string(xml).parse
+    assert_equal(Array.new, messages)
+    
+    XML::Parser.default_load_external_dtd = true
+    doc = XML::Parser.string(xml).parse
+    assert_equal('I/O warning : failed to load external entity "test.dtd" <!DOCTYPE test PUBLIC "-//TEST" "test.dtd" []> ^',
+                 messages.map{|msg| msg.strip}.join(' ')) 
+  end
+end

data/test/tc_xml_node.rb

@@ -80,6 +80,19 @@ class TestNode < Test::Unit::TestCase
     assert(!node_a.equal?(node_a2))
   end
       
+  def test_equality_nil
+    node = @doc.root
+    assert(node != nil)
+  end
+  
+  def test_equality_wrong_type
+    node = @doc.root
+    
+    assert_raises(TypeError) do
+      assert(node != 'abc')
+    end
+  end
+
   def test_content()
     assert_equal('onetwo', @doc.root.content)
     

data/test/tc_xml_node_edit.rb

@@ -1,7 +1,7 @@
 require "libxml"
 require 'test/unit'
 
-class TextNodeEdit < Test::Unit::TestCase
+class TestNodeEdit < Test::Unit::TestCase
   def setup
     xp = XML::Parser.new()
     xp.string = '<test><num>one</num><num>two</num><num>three</num></test>'

data/test/tc_xml_node_xlink.rb

@@ -1,4 +1,4 @@
-# $Id: tc_xml_node_xlink.rb 251 2008-01-22 18:12:00Z transami $
+# $Id: tc_xml_node_xlink.rb 453 2008-07-15 19:36:12Z cfis $
 require "libxml"
 require 'test/unit'
 

data/test/tc_xml_parser.rb

@@ -1,14 +1,18 @@
 require "libxml"
 require 'test/unit'
 
-class TextParser < Test::Unit::TestCase
+class TestParser < Test::Unit::TestCase
   def setup
+    XML::Parser.register_error_handler(nil)
     @xp = XML::Parser.new
-    assert_not_nil(@xp)
   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  ------
@@ -157,7 +161,7 @@ class TextParser < Test::Unit::TestCase
   end
 
   def test_file
-    file = File.expand_path('model/rubynet.xml')
+    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
     
     @xp.filename = file
     assert_equal(file, @xp.filename)
@@ -167,21 +171,71 @@ class TextParser < Test::Unit::TestCase
   end
 
   def test_io
-    File.open('model/rubynet.xml') do |f|
+    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 # File.open
   end # def test_libxml_parser_io
 
+  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::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
-    $stderr.puts "\nEXPECTING: TWO ERRORS:"
-    # this will send message to stderr
+    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
+    
+    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
@@ -211,12 +265,14 @@ class TextParser < Test::Unit::TestCase
   
   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
     
@@ -228,6 +284,7 @@ class TextParser < Test::Unit::TestCase
   def test_libxml_parser_empty_string
     assert_raise(XML::Parser::ParseError) do
       @xp.string = ''
+      @xp.parse
     end
     
     assert_raise(TypeError) do

data/test/tc_xml_properties.rb

@@ -0,0 +1,42 @@
+require "libxml"
+require 'test/unit'
+
+# Properties is deprecated - use attributes instead.
+# Tests for backwards compatibility
+
+class TestProperties < 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
+    properties = @doc.root.properties
+    
+    assert_instance_of(XML::Attributes, properties)
+    attribute = properties.first
+    assert_equal('uga', attribute.name)
+    assert_equal('booga', attribute.value)
+
+    attribute = attribute.next
+    assert_instance_of(XML::Attr, attribute)
+    assert_equal('foo', attribute.name)
+    assert_equal('bar', attribute.value)
+  end
+  
+  def test_each_attr
+    @doc.root.properties.each_attr do |attribute|
+      assert_instance_of(XML::Attr, attribute)
+    end
+  end
+  
+  def test_no_properties
+    properties = @doc.root.child.properties
+    assert_instance_of(XML::Attributes, properties)
+    assert_equal(0, properties.length)
+  end
+end

data/test/tc_xml_reader.rb

@@ -7,18 +7,18 @@ class TC_XML_Reader < Test::Unit::TestCase
 
   def test_new_file
     reader = XML::Reader.file(SIMPLE_XML)
-    do_test_simple(reader)
+    verify_simple(reader)
     assert_raises(RuntimeError) { XML::Reader.file('/does/not/exist') }
   end
 
   def test_new_data
     reader = XML::Reader.new(File.read(SIMPLE_XML))
-    do_test_simple(reader)
+    verify_simple(reader)
   end
 
   def test_new_walker
     reader = XML::Reader.walker(XML::Document.file(SIMPLE_XML))
-    do_test_simple(reader)
+    verify_simple(reader)
   end
 
   def test_reader_error
@@ -81,7 +81,7 @@ class TC_XML_Reader < Test::Unit::TestCase
     doc.standalone?
   end
 
-  def do_test_simple(reader)
+  def verify_simple(reader)
     node_types = []
     19.times do
       assert_equal(1, reader.read)

data/test/tc_xml_sax_parser.rb

@@ -3,58 +3,72 @@ require 'test/unit'
 
 # TODO this is woefully inadequate
 
-class TC_XML_SaxParser2 < Test::Unit::TestCase
-  class TestCaseCallbacks
-    include XML::SaxParser::Callbacks
+class TestCaseCallbacks
+  include XML::SaxParser::Callbacks
 
-    attr_accessor :test
+  attr_accessor :test
 
-    def initialize
-      @test = Hash.new { |h,k| h[k] = [] }
-      @i = 0
-    end
+  def initialize
+    @test = Hash.new { |h,k| h[k] = [] }
+    @i = 0
+  end
 
-    def on_start_document
-      @test[:startdoc] << @i+=1
-    end
+  def on_start_document
+    @test[:startdoc] << @i+=1
+  end
 
-    def on_start_element(name, attr_hash)
-      @test[:startel] << [@i+=1,name,attr_hash]
-    end
+  def on_start_element(name, attr_hash)
+    @test[:startel] << [@i+=1,name,attr_hash]
+  end
 
-    def on_characters(chars)
-      @test[:chars] << [@i+=1,chars]
-    end
+  def on_characters(chars)
+    @test[:chars] << [@i+=1,chars]
+  end
 
-    def on_comment(msg)
-      @test[:comment] << [@i+=1,msg]
-    end
+  def on_comment(msg)
+    @test[:comment] << [@i+=1,msg]
+  end
 
-    def on_processing_instruction(target, data)
-      @test[:pinstr] << [@i+=1, target, data]
-    end
+  def on_processing_instruction(target, data)
+    @test[:pinstr] << [@i+=1, target, data]
+  end
 
-    def on_cdata_block(cdata)
-      @test[:cdata] << [@i+=1,cdata]
-    end
+  def on_cdata_block(cdata)
+    @test[:cdata] << [@i+=1,cdata]
+  end
 
-    def on_end_element(name)
-      @test[:endel] << [@i+=1,name]
-    end
+  def on_end_element(name)
+    @test[:endel] << [@i+=1,name]
+  end
 
-    def on_end_document
-      @test[:enddoc] << @i+=1
-    end
+  def on_end_document
+    @test[:enddoc] << @i+=1
   end
+end
 
-  def setup()
+class TestSaxParser < Test::Unit::TestCase
+  def setup
     @xp = XML::SaxParser.new
   end
 
-  def teardown()
+  def teardown
     @xp = nil
   end
 
+  def verify
+    @xp.parse
+    assert_equal [1], @xp.callbacks.test[:startdoc]
+    assert_equal [[2,'test',{'uga'=>'booga','foo'=>'bar'}],[3,'fixnum',{}],[6,'fixnum',{}]],
+                 @xp.callbacks.test[:startel]
+    assert_equal [[4,'one'],[7,'two'],[9,"\n  "],[11,"\n  "],[13,"\n  "],[15,"\n"]],
+                 @xp.callbacks.test[:chars]
+    assert_equal [[10, ' msg ']], @xp.callbacks.test[:comment]
+    assert_equal [[12, 'custom', 'foo="bar"']], @xp.callbacks.test[:pinstr]
+    assert_equal [[14, 'here it goes']], @xp.callbacks.test[:cdata]
+    assert_equal [[5,'fixnum'],[8,'fixnum'],[16,'test']], @xp.callbacks.test[:endel]
+    assert_equal [17], @xp.callbacks.test[:enddoc]
+  end
+  
   def test_string_without_callbacks
     @xp.string = File.read(File.join(File.dirname(__FILE__), 'model/saxtest.xml'))
     assert_equal true, @xp.parse
@@ -68,29 +82,15 @@ class TC_XML_SaxParser2 < Test::Unit::TestCase
   def test_callbacks_with_string
     @xp.callbacks = TestCaseCallbacks.new
     @xp.string = File.read(File.join(File.dirname(__FILE__), 'model/saxtest.xml'))
-    do_test
+    verify
   end
 
   def test_callbacks_with_file
     @xp.callbacks = TestCaseCallbacks.new
     @xp.filename = File.join(File.dirname(__FILE__), 'model/saxtest.xml')
-    do_test
+    verify
   end
 
-  def do_test
-    @xp.parse
-    assert_equal [1], @xp.callbacks.test[:startdoc]
-    assert_equal [[2,'test',{'uga'=>'booga','foo'=>'bar'}],[3,'fixnum',{}],[6,'fixnum',{}]],
-                 @xp.callbacks.test[:startel]
-    assert_equal [[4,'one'],[7,'two'],[9,"\n  "],[11,"\n  "],[13,"\n  "],[15,"\n"]],
-                 @xp.callbacks.test[:chars]
-    assert_equal [[10, ' msg ']], @xp.callbacks.test[:comment]
-    assert_equal [[12, 'custom', 'foo="bar"']], @xp.callbacks.test[:pinstr]
-    assert_equal [[14, 'here it goes']], @xp.callbacks.test[:cdata]
-    assert_equal [[5,'fixnum'],[8,'fixnum'],[16,'test']], @xp.callbacks.test[:endel]
-    assert_equal [17], @xp.callbacks.test[:enddoc]
-  end
-  
   def test_doctype
     @xp.callbacks = TestCaseCallbacks.new
     @xp.string = <<-EOS