libxml-jruby 1.0.0

data/test/tc_node.rb

@@ -0,0 +1,108 @@
+require "xml"
+require 'test/unit'
+
+class TestNode < Test::Unit::TestCase
+  def setup
+    xp = XML::Parser.new()
+    str = '<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
+    assert_equal(str, xp.string = str)
+    @doc = xp.parse
+  end
+  
+  def teardown
+    @doc = nil
+  end
+  
+  def nodes
+    @doc.find('/ruby_array/fixnum')
+  end
+
+  def test_doc_class
+    assert_instance_of(XML::Document, @doc)
+  end
+  
+  def test_root_class
+    assert_instance_of(XML::Node, @doc.root)
+  end
+  
+  def test_node_class
+    for n in nodes
+      assert_instance_of(XML::Node, n)
+    end
+  end
+
+  def test_find_class
+    set = @doc.find('/ruby_array/fixnum')
+    assert_instance_of(XML::XPath::Object, set)
+  end
+
+  def test_node_child_get
+    assert_instance_of(TrueClass, @doc.root.child?)
+    assert_instance_of(XML::Node, @doc.root.child)
+    assert_equal('fixnum', @doc.root.child.name)
+  end
+
+  def test_node_doc
+    for n in nodes
+      assert_instance_of(XML::Document, n.doc) if n.document?
+    end
+  end
+
+  def test_node_type_name
+    assert_equal('element', nodes[0].node_type_name)
+    assert_equal('element', nodes[1].node_type_name)
+  end
+
+  def test_node_find
+    set = @doc.root.find('./fixnum').set
+    assert_instance_of(XML::Node::Set, set)
+    for node in set
+      assert_instance_of(XML::Node, node)
+    end
+  end
+  
+  def test_equality
+    node_a = @doc.find('/ruby_array/fixnum').first
+    node_b = @doc.root.child
+    assert(node_a == node_b)
+    assert(node_a.eql?(node_b))
+    assert(node_a.equal?(node_b))
+    
+    xp2 = XML::Parser.new()
+    xp2.string = '<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
+    doc2 = xp2.parse
+
+    node_a2 = doc2.find('/ruby_array/fixnum').first
+    
+    assert(node_a.to_s == node_a2.to_s)
+    assert(node_a == node_a2)
+    assert(node_a.eql?(node_a2))
+    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)
+    
+    first = @doc.root.child
+    assert_equal('one', first.content)
+    assert_equal('two', first.next.content)
+  end
+  
+  def test_base
+    doc = XML::Parser.string('<person />').parse
+    assert_nil(doc.root.base)
+  end
+end

data/test/tc_node_attr.rb

@@ -0,0 +1,176 @@
+require "xml"
+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)
+
+    # FIXME Namespaced attribute, without namespace specified    
+    # 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)
+
+    # FIXME This should be working, review ASAP
+    # 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)
+
+    # FIXME Namespaced attribute, without namespace specified    
+    # 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)
+
+    # FIXME Namespaced attribute, without namespace specified
+    # 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)
+    # FIXME I'm not sure what is going on here, look at Attr#initialize
+    # 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
+  
+  # FIXME Ordering of Attributes is not implemented yet
+  # 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_node_cdata.rb

@@ -0,0 +1,51 @@
+require 'xml'
+require 'test/unit'
+
+class CDataCommentTest < Test::Unit::TestCase
+  def setup
+    xp = XML::Parser.new()
+    str = '<root></root>'
+    assert_equal(str, xp.string = str)
+    @doc = xp.parse
+    assert_instance_of(XML::Document, @doc)
+    @root = @doc.root
+  end
+
+  def test_node_type
+    cnode = XML::Node.new_cdata('test cdata')
+    assert_equal(XML::Node::CDATA_SECTION_NODE, cnode.node_type)
+  end
+
+  def test_add_cdata
+    @root << XML::Node.new_cdata('mycdata')
+    assert_equal '<root><![CDATA[mycdata]]></root>',
+      @root.to_s.gsub(/\n\s*/,'')
+  end
+
+  def test_add_cdata_2
+    @root << XML::Node.new_cdata('mycdata')
+    assert_equal 'cdata',
+    @root.child.node_type_name
+  end
+
+  def test_add_cdata_3
+    @root << el = XML::Node.new_cdata('mycdata')
+    el << "_this_is_added"
+    assert_equal '<root><![CDATA[mycdata_this_is_added]]></root>',
+      @root.to_s.gsub(/\n\s*/,'')
+  end
+  
+  def test_attributes
+    cnode = XML::Node.new_cdata('test cdata')
+    assert_equal(0, cnode.attributes.length)
+  end
+  
+  def test_set_cdata_attribute
+    cnode = XML::Node.new_cdata('test cdata')
+    
+    # Can't create attributes on non-element nodes
+    assert_raise(ArgumentError) do
+      cnode['attr'] = '123'
+    end
+  end
+end

data/test/tc_node_comment.rb

@@ -0,0 +1,32 @@
+require "xml"
+require 'test/unit'
+
+class NodeCommentTest < Test::Unit::TestCase
+  def setup()
+    xp = XML::Parser.new()
+    str = '<root></root>'
+    assert_equal(str, xp.string = str)
+    @doc = xp.parse
+    assert_instance_of(XML::Document, @doc)
+    @root = @doc.root
+  end
+
+  def test_libxml_node_add_comment_01
+    @root << XML::Node.new_comment('mycomment')
+    assert_equal '<root><!--mycomment--></root>',
+      @root.to_s.gsub(/\n\s*/,'')
+  end
+
+  def test_libxml_node_add_comment_02
+    @root << XML::Node.new_comment('mycomment')
+    assert_equal 'comment',
+    @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*/,'')
+  end
+end

data/test/tc_node_copy.rb

@@ -0,0 +1,40 @@
+require "xml"
+require 'test/unit'
+
+# see mailing list archive
+# [libxml-devel] Segmentation fault when add the cloned/copied node
+# 2007/11/27 20:51
+
+class TC_XML_Node_Copy < Test::Unit::TestCase
+  def setup
+    str = <<-STR
+      <html><body>
+        <div class="textarea" id="t1" style="STATIC">foo</div>
+        <div class="textarea" id="t2" style="STATIC">bar</div>
+      </body></html>
+    STR
+
+    doc = XML::Parser.string(str).parse
+
+    xpath = "//div"
+    @div1 = doc.find(xpath).to_a[0]
+    @div2 = doc.find(xpath).to_a[1]
+  end
+
+  def test_libxml_node_copy_not_segv
+    @div2.each do |child|
+      c = child.copy(false)
+      @div1.child_add(c)
+    end
+    assert @div1.to_s =~ /foo/
+  end
+
+  def test_libxml_node_clone_not_segv
+    @div2.each do |child|
+      c = child.clone
+      @div1.child_add(c)
+    end
+    assert @div1.to_s =~ /foo/
+  end
+
+end # TC_XML_Node_Copy

data/test/tc_node_edit.rb

@@ -0,0 +1,98 @@
+require "xml"
+require 'test/unit'
+
+class TestNodeEdit < 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
+  
+  def test_append_chain
+    node = XML::Node.new('foo') << XML::Node.new('bar') << "bars contents"
+    assert_equal('bars contents',
+                 node.to_s)
+    assert_equal("<foo>\n  <bar>bars contents</bar>\n</foo>", node.parent.parent.to_s)
+  end
+end