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

data/test/tc_xml_node_attr.rb

@@ -0,0 +1,170 @@
+require "libxml"
+require 'test/unit'
+
+class AttrNodeTest < Test::Unit::TestCase
+  def setup()
+    xp = XML::Parser.string(<<-EOS)
+    <CityModel
+      xmlns="http://www.opengis.net/examples"
+      xmlns:city="http://www.opengis.net/examples"
+      xmlns:gml="http://www.opengis.net/gml"
+      xmlns:xlink="http://www.w3.org/1999/xlink"
+      xmlns:xsi="http://www.w3.org/2000/10/XMLSchema-instance"
+      xsi:schemaLocation="http://www.opengis.net/examples city.xsd">
+      <type>City</type>
+      <cityMember name="Cambridge" 
+                  xlink:type="simple"
+                  xlink:title="Trinity Lane"
+                  xlink:href="http://www.foo.net/cgi-bin/wfs?FeatureID=C10239"
+                  gml:remoteSchema="city.xsd#xpointer(//complexType[@name='RoadType'])"/>
+    </CityModel>
+    EOS
+    
+    @doc = xp.parse
+  end
+  
+  def teardown()
+    @doc = nil
+  end
+  
+  def city_member
+    @doc.find('/city:CityModel/city:cityMember').first
+  end
+  
+  def test_types
+    attribute = city_member.attributes.get_attribute('name')
+    assert_instance_of(XML::Attr, attribute)
+    assert_equal('attribute', attribute.node_type_name)
+  end
+  
+  def test_name
+    attribute = city_member.attributes.get_attribute('name')
+    assert_equal('name', attribute.name)
+    
+    attribute = city_member.attributes.get_attribute('href')
+    assert_equal('href', attribute.name)
+    assert_equal('xlink', attribute.ns.prefix)
+    assert_equal('http://www.w3.org/1999/xlink', attribute.ns.href)
+    
+    attribute = city_member.attributes.get_attribute_ns('http://www.w3.org/1999/xlink', 'href')
+    assert_equal('href', attribute.name)
+    assert_equal('xlink', attribute.ns.prefix)
+    assert_equal('http://www.w3.org/1999/xlink', attribute.ns.href)
+  end
+  
+  def test_value
+    attribute = city_member.attributes.get_attribute('name')
+    assert_equal('Cambridge', attribute.value)
+    
+    attribute = city_member.attributes.get_attribute('href')
+    assert_equal('http://www.foo.net/cgi-bin/wfs?FeatureID=C10239', attribute.value)
+  end
+  
+  def test_set_value
+    attribute = city_member.attributes.get_attribute('name')
+    attribute.value = 'London'
+    assert_equal('London', attribute.value)
+    
+    attribute = city_member.attributes.get_attribute('href')
+    attribute.value = 'http://i.have.changed'
+    assert_equal('http://i.have.changed', attribute.value)
+  end
+  
+  def test_set_nil
+    attribute = city_member.attributes.get_attribute('name')
+    assert_raise(TypeError) do
+      attribute.value = nil
+    end
+  end
+  
+  def test_create
+    attributes = city_member.attributes
+    assert_equal(5, attributes.length)
+    
+    attr = XML::Attr.new(city_member, 'size', '50,000')
+    assert_instance_of(XML::Attr, attr)
+    
+    attributes = city_member.attributes
+    assert_equal(6, attributes.length)
+    
+    assert_equal(attributes['size'], '50,000')
+  end
+  
+  def test_create_on_node
+    attributes = city_member.attributes
+    assert_equal(5, attributes.length)
+    
+    attributes['country'] = 'England'
+    
+    attributes = city_member.attributes
+    assert_equal(6, attributes.length)
+    
+    assert_equal(attributes['country'], 'England')
+  end
+  
+  def test_create_ns
+    assert_equal(5, city_member.attributes.length)
+    
+    ns = XML::NS.new(city_member, 'my_namepace', 'http://www.mynamespace.com')
+    attr = XML::Attr.new(city_member, 'rating', 'rocks', ns)
+    assert_instance_of(XML::Attr, attr)
+    assert_equal('rating', attr.name)
+    assert_equal('rocks', attr.value)
+    
+    attributes = city_member.attributes
+    assert_equal(6, attributes.length)
+    
+    assert_equal('rocks', city_member['rating'])
+  end
+
+  def test_remove
+    attributes = city_member.attributes
+    assert_equal(5, attributes.length)
+    
+    attribute = attributes.get_attribute('name')
+    assert_not_nil(attribute.parent)
+    assert(attribute.parent?)
+    
+    attribute.remove!
+    assert_equal(4, attributes.length)
+    assert_nil(attribute.parent)
+    assert(!attribute.parent?)
+  end
+  
+  def test_first
+    attribute = city_member.attributes.first
+    assert_instance_of(XML::Attr, attribute)
+    assert_equal('name', attribute.name)
+    assert_equal('Cambridge', attribute.value)
+    
+    attribute = attribute.next
+    assert_instance_of(XML::Attr, attribute)
+    assert_equal('type', attribute.name)
+    assert_equal('simple', attribute.value)
+
+    attribute = attribute.next
+    assert_instance_of(XML::Attr, attribute)
+    assert_equal('title', attribute.name)
+    assert_equal('Trinity Lane', attribute.value)
+    
+    attribute = attribute.next
+    assert_instance_of(XML::Attr, attribute)
+    assert_equal('href', attribute.name)
+    assert_equal('http://www.foo.net/cgi-bin/wfs?FeatureID=C10239', attribute.value)
+
+    attribute = attribute.next
+    assert_instance_of(XML::Attr, attribute)
+    assert_equal('remoteSchema', attribute.name)
+    assert_equal("city.xsd#xpointer(//complexType[@name='RoadType'])", attribute.value)
+    
+    attribute = attribute.next
+    assert_nil(attribute)
+  end
+
+  def test_no_attributes
+    element = @doc.find('/city:CityModel/city:type').first
+
+    assert_not_nil(element.attributes)
+    assert_equal(0, element.attributes.length)
+  end
+end

data/test/{tc_xml_node8.rb → tc_xml_node_cdata.rb}

@@ -1,7 +1,7 @@
 require "libxml"
 require 'test/unit'
 
-class TC_XML_Node8 < Test::Unit::TestCase
+class CDataCommentTest < Test::Unit::TestCase
   def setup()
     xp = XML::Parser.new()
     str = '<root></root>'
@@ -20,7 +20,7 @@ class TC_XML_Node8 < Test::Unit::TestCase
   def test_libxml_node_add_cdata_02
     @root << XML::Node.new_cdata('mycdata')
     assert_equal 'cdata',
-		@root.child.node_type_name
+    @root.child.node_type_name
   end
 
   def test_libxml_node_add_cdata_03

data/test/{tc_xml_node9.rb → tc_xml_node_comment.rb}

@@ -1,7 +1,7 @@
 require "libxml"
 require 'test/unit'
 
-class TC_XML_Node9 < Test::Unit::TestCase
+class NodeCommentTest < Test::Unit::TestCase
   def setup()
     xp = XML::Parser.new()
     str = '<root></root>'
@@ -20,13 +20,13 @@ class TC_XML_Node9 < Test::Unit::TestCase
   def test_libxml_node_add_comment_02
     @root << XML::Node.new_comment('mycomment')
     assert_equal 'comment',
-		@root.child.node_type_name
+    @root.child.node_type_name
   end
 
   def test_libxml_node_add_comment_03
     @root << el = XML::Node.new_comment('mycomment')
     el << "_this_is_added"
     assert_equal '<root><!--mycomment_this_is_added--></root>',
-		@root.to_s.gsub(/\n\s*/,'')
+    @root.to_s.gsub(/\n\s*/,'')
   end
 end

data/test/tc_xml_node_edit.rb

@@ -0,0 +1,91 @@
+require "libxml"
+require 'test/unit'
+
+class TextNodeEdit < Test::Unit::TestCase
+  def setup
+    xp = XML::Parser.new()
+    xp.string = '<test><num>one</num><num>two</num><num>three</num></test>'
+    @doc = xp.parse
+  end
+
+  def teardown
+    @doc = nil
+  end
+  
+  def first_node
+    @doc.root.child
+  end
+  
+  def second_node
+    first_node.next
+  end
+  
+  def third_node
+    second_node.next
+  end
+ 
+  def test_add_next_01
+    first_node.next = XML::Node.new('num', 'one-and-a-half')
+    assert_equal('<test><num>one</num><num>one-and-a-half</num><num>two</num><num>three</num></test>',
+                 @doc.root.to_s.gsub(/\n\s*/,''))
+  end
+
+  def test_add_next_02
+    second_node.next = XML::Node.new('num', 'two-and-a-half')
+    assert_equal('<test><num>one</num><num>two</num><num>two-and-a-half</num><num>three</num></test>',
+                 @doc.root.to_s.gsub(/\n\s*/,''))
+  end
+
+  def test_add_next_03
+    third_node.next = XML::Node.new('num', 'four')
+    assert_equal '<test><num>one</num><num>two</num><num>three</num><num>four</num></test>',
+      @doc.root.to_s.gsub(/\n\s*/,'')
+  end
+
+  def test_add_prev_01
+    first_node.prev = XML::Node.new('num', 'half')
+    assert_equal '<test><num>half</num><num>one</num><num>two</num><num>three</num></test>',
+      @doc.root.to_s.gsub(/\n\s*/,'')
+  end
+
+  def test_add_prev_02
+    second_node.prev = XML::Node.new('num', 'one-and-a-half')
+    assert_equal '<test><num>one</num><num>one-and-a-half</num><num>two</num><num>three</num></test>',
+      @doc.root.to_s.gsub(/\n\s*/,'')
+  end
+
+  def test_add_prev_03
+    third_node.prev = XML::Node.new('num', 'two-and-a-half')
+    assert_equal '<test><num>one</num><num>two</num><num>two-and-a-half</num><num>three</num></test>',
+      @doc.root.to_s.gsub(/\n\s*/,'')
+  end
+  
+  def test_remove_node()
+    first_node.remove!
+    assert_equal('<test><num>two</num><num>three</num></test>',
+                 @doc.root.to_s.gsub(/\n\s*/,''))
+  end
+
+  # This test is to verify that an earlier reported bug has been fixed  
+  def test_merge
+    documents = []
+
+    # Read in 500 documents
+    500.times do
+      documents << XML::Parser.string(File.read(File.join(File.dirname(__FILE__), 'model', 'merge_bug_data.xml'))).parse
+    end
+
+    master_doc = documents.shift
+    documents.inject(master_doc) do |master_doc, child_doc|
+      master_body = master_doc.find("//body").first
+      child_body = child_doc.find("//body").first
+      
+      child_element = child_body.detect do |node|
+        node.element?
+      end
+      
+      master_body << child_element.copy(true)
+      master_doc
+    end
+  end
+end

data/test/tc_xml_parser.rb

@@ -1,44 +1,22 @@
 require "libxml"
 require 'test/unit'
 
-class TC_XML_Parser < Test::Unit::TestCase
-  def setup()
-    @xp = XML::Parser.new()
+class TextParser < Test::Unit::TestCase
+  def setup
+    @xp = XML::Parser.new
     assert_not_nil(@xp)
   end
 
-  def teardown()
+  def teardown
     @xp = nil
   end
-
-  def test_libxml_parser_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_libxml_parser_bad_xml()
-    @xp.string = '<ruby_array uga="booga" foo="bar"<fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
-    assert_raise(XML::Parser::ParseError) do
-      assert_not_nil(@xp.parse)
-    end
-  end
-
-  def test_libxml_parser_empty_string
-    assert_raise(XML::Parser::ParseError) do
-      @xp.string = ''
-    end
-    
-    assert_raise(TypeError) do
-      @xp.string = nil
-    end
-  end
       
-  def test_ruby_xml_parser_check_lib_versions()
+  # -----  Constants  ------
+  def test_lib_versions
     assert(XML::Parser::check_lib_versions)
   end
 
-  def test_ruby_xml_parser_debug_entities()
+  def test_debug_entities
     XML::Parser::debug_entities = false
     assert(!XML::Parser::debug_entities)
 
@@ -49,7 +27,9 @@ class TC_XML_Parser < Test::Unit::TestCase
     assert(!XML::Parser::debug_entities)
   end
 
-  def test_ruby_xml_parser_default_compression()
+  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)
@@ -71,7 +51,7 @@ class TC_XML_Parser < Test::Unit::TestCase
     end
   end
 
-  def test_ruby_xml_parser_default_keep_blanks()
+  def test_default_keep_blanks
     XML::Parser::default_keep_blanks = false
     assert(!XML::Parser::default_keep_blanks)
 
@@ -86,7 +66,7 @@ class TC_XML_Parser < Test::Unit::TestCase
     XML::Parser::default_keep_blanks = true
   end
 
-  def test_ruby_xml_parser_default_line_numbers()
+  def test_default_line_numbers
     XML::Parser::default_line_numbers = false
     assert(!XML::Parser::default_line_numbers)
 
@@ -97,7 +77,7 @@ class TC_XML_Parser < Test::Unit::TestCase
     assert(!XML::Parser::default_line_numbers)
   end
 
-  def test_ruby_xml_parser_default_substitute_entities()
+  def test_default_substitute_entities
     XML::Parser::default_substitute_entities = false
     assert(!XML::Parser::default_substitute_entities)
 
@@ -108,21 +88,21 @@ class TC_XML_Parser < Test::Unit::TestCase
     assert(!XML::Parser::default_substitute_entities)
   end
 
-  def test_ruby_xml_parser_default_tree_indent_string()
-    s = XML::Parser::default_tree_indent_string()
+  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()
+    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()
+    s = XML::Parser::default_tree_indent_string
     assert_instance_of(String, s)
     assert_equal('  ', s)
   end
 
-  def test_ruby_xml_parser_default_validity_checking()
+  def test_default_validity_checking
     XML::Parser::default_validity_checking = false
     assert(!XML::Parser::default_validity_checking)
 
@@ -133,7 +113,7 @@ class TC_XML_Parser < Test::Unit::TestCase
     assert(!XML::Parser::default_validity_checking)
   end
 
-  def test_ruby_xml_parser_default_warnings()
+  def test_default_warnings
     XML::Parser::default_warnings = false
     assert(!XML::Parser::default_warnings)
 
@@ -144,7 +124,7 @@ class TC_XML_Parser < Test::Unit::TestCase
     assert(!XML::Parser::default_warnings)
   end
 
-  def test_ruby_xml_parser_intent_tree_output()
+  def test_intent_tree_output
     assert(TrueClass, XML::Parser::indent_tree_output)
 
     XML::Parser::indent_tree_output = false
@@ -154,37 +134,104 @@ class TC_XML_Parser < Test::Unit::TestCase
     assert(TrueClass, XML::Parser::indent_tree_output)
   end
 
-  def test_ruby_xml_parser_version()
+  def test_version
     assert_instance_of(String, XML::Parser::VERSION)
   end
 
-  def test_ruby_xml_parser_vernum()
+  def test_vernum
     assert_instance_of(Fixnum, XML::Parser::VERNUM)
   end
 
-  def test_ruby_xml_parser_context()
+  # -----  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)
     assert_instance_of(XML::Parser::Context, @xp.context)
   end
 
-  def test_libxml_parser_file()
+  def test_file
     file = File.expand_path('model/rubynet.xml')
     
-    assert_equal(file, @xp.filename = file)
-    assert_instance_of(XML::Document, @xp.parse)
+    @xp.filename = file
+    assert_equal(file, @xp.filename)
+    
+    doc = @xp.parse
+    assert_instance_of(XML::Document, doc)
   end
 
-  def test_libxml_parser_io()
+  def test_io
     File.open('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()
+  end # def test_libxml_parser_io
 
-  def test_libxml_parser_features()
+  def test_libxml_parser_features
     assert_instance_of(Array, XML::Parser::features)
   end
-end # TC_XML_Parser
+  
+  # -----  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 = []
+    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
+    
+    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>'
+    assert_raise(XML::Parser::ParseError) do
+      assert_not_nil(@xp.parse)
+    end
+  end
+  
+  def test_double_parse
+    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 = ''
+    end
+    
+    assert_raise(TypeError) do
+      @xp.string = nil
+    end
+  end
+end