libxml-jruby-modified 1.0.1-jruby

data/test/tc_document.rb

@@ -0,0 +1,97 @@
+require "xml"
+require 'test/unit'
+
+
+class TC_XML_Document < Test::Unit::TestCase
+  def setup
+    xp = XML::Parser.new
+    assert_instance_of(XML::Parser, xp)
+    str = '<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
+    assert_equal(str, xp.string = str)
+    @doc = xp.parse
+    assert_instance_of(XML::Document, @doc)
+  end
+
+  def teardown
+    @doc = nil
+  end
+
+  def test_libxml_document_find
+    set = @doc.find('/ruby_array/fixnum')
+    assert_instance_of(XML::XPath::Object, set)
+    assert_raise(NoMethodError) {
+      xpt = set.xpath
+    }
+  end
+
+  # FIXME XML::Parser::enabled_zlib? zlib support
+  # def test_ruby_xml_document_compression
+  #   if XML::Parser::enabled_zlib?
+  #     0.upto(9) do |i|
+  #       assert_equal(i, @doc.compression = i)
+  #       assert_equal(i, @doc.compression)
+  #     end
+  # 
+  #     9.downto(0) do |i|
+  #       assert_equal(i, @doc.compression = i)
+  #       assert_equal(i, @doc.compression)
+  #     end
+  # 
+  #     10.upto(20) do |i|
+  #       # assert_equal(9, @doc.compression = i)
+  #       assert_equal(i, @doc.compression = i) # This works around a bug in Ruby 1.8
+  #       assert_equal(9, @doc.compression)
+  #     end
+  # 
+  #     -1.downto(-10) do |i|
+  #       # assert_equal(0, @doc.compression = i)
+  #       assert_equal(i, @doc.compression = i) # FIXME This bug should get fixed ASAP
+  #       assert_equal(0, @doc.compression)
+  #     end
+  #   end
+  # end
+  
+# FIXME Document#save
+#   def test_save
+#     filename = 'test_write' 
+#     bytes = @doc.save(filename)
+#     assert_equal(110, bytes)
+#     contents = File.read(filename)
+#     
+#     expected =<<-EOS
+# <?xml version="1.0"?>
+# <ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>
+# EOS
+#     assert_equal(expected, contents)
+#   ensure
+#     File.delete(filename)    
+#   end
+
+# FIXME Document#save  
+#   def test_save_formatted
+#     filename = 'test_write' 
+#     bytes = @doc.save(filename, true)
+#     assert_equal(117, bytes)
+#     contents = File.read(filename)
+#     
+#     expected =<<-EOS
+# <?xml version="1.0"?>
+# <ruby_array uga="booga" foo="bar">
+#   <fixnum>one</fixnum>
+#   <fixnum>two</fixnum>
+# </ruby_array>
+# EOS
+#     assert_equal(expected, contents)
+#   ensure
+#     File.delete(filename)    
+#   end
+  
+  # FIXME Document#save
+  # def test_save_formatted_invalid
+  #   filename = 'test_write' 
+  #   
+  #   assert_raise(ArgumentError) do
+  #     @doc.save(filename, 1)
+  #   end
+  # end  
+end

data/test/tc_document_write.rb

@@ -0,0 +1,139 @@
+require "xml"
+require 'test/unit'
+
+class TC_XML_Document_Write < Test::Unit::TestCase
+  def setup
+    @doc = XML::Document.new('1.0')
+  end
+
+  def teardown
+    @doc = nil
+  end
+
+  def test_klass
+    assert_instance_of(XML::Document, @doc)
+  end
+
+  def test_version
+    assert_equal('1.0', @doc.version)
+
+    doc = XML::Document.new('6.9')
+    assert_equal('6.9', doc.version)
+  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_dtd.rb

@@ -0,0 +1,70 @@
+require "xml"
+require 'test/unit'
+
+class TestDtd < Test::Unit::TestCase
+  def setup
+    xp = XML::Parser.string(<<-EOS)
+      <root>
+        <head a="ee" id="1">Colorado</head>
+        <descr>Lots of nice mountains</descr>
+      </root>
+    EOS
+    @doc = xp.parse
+  end
+  
+  def teardown
+    @doc = nil
+  end
+  
+  def dtd
+    XML::Dtd.new(<<-EOS)
+      <!ELEMENT root (head, descr)>
+      <!ELEMENT head (#PCDATA)>
+      <!ATTLIST head
+        id NMTOKEN #REQUIRED
+        a CDATA #IMPLIED
+      >
+      <!ELEMENT descr (#PCDATA)>
+    EOS
+  end
+  
+  def test_valid
+    assert(@doc.validate(dtd))
+  end
+  
+  def test_invalid
+    new_node = XML::Node.new('invalid', 'this will mess up validation')
+    @doc.root.child_add(new_node)
+    
+    messages = Hash.new
+    assert(!@doc.validate(dtd) do |message, error|
+      messages[message] = error
+    end)
+
+    expected = {"No declaration for element invalid\n" => true,
+                "Element root content does not follow the DTD, expecting (head , descr), got (head descr invalid)\n" => true}
+      
+    assert_equal(expected, messages)
+  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_html_parser.rb

@@ -0,0 +1,63 @@
+require "xml"
+require 'test/unit'
+
+class TC_XML_HTMLParser < Test::Unit::TestCase
+  def setup()
+    @xp = XML::HTMLParser.new()
+    assert_not_nil(@xp)
+    str = '<html><head><meta name=keywords content=nasty></head><body>Hello<br>World</html>'
+    @xp.string = str
+    assert_equal(str, @xp.string)
+  end
+
+  def teardown()
+    @xp = nil
+  end
+
+  def test_libxml_html_parser_parse()
+    doc = @xp.parse
+
+    assert_instance_of XML::Document, doc
+
+    root = doc.root
+    assert_instance_of XML::Node, root
+    assert_equal 'html', root.name
+
+    head = root.child
+    assert_instance_of XML::Node, head
+    assert_equal 'head', head.name
+
+    meta = head.child
+    assert_instance_of XML::Node, meta
+    assert_equal 'meta', meta.name
+    assert_equal 'keywords', meta[:name]
+    assert_equal 'nasty', meta[:content]
+
+    body = head.next
+    assert_instance_of XML::Node, body
+    assert_equal 'body', body.name
+
+    hello = body.child
+    # It appears that some versions of libxml2 add a layer of <p>
+    # cant figure our why or how, so this skips it if there
+    hello = hello.child if hello.name == "p"
+
+    assert_instance_of XML::Node, hello
+    assert_equal 'Hello', hello.content
+
+    br = hello.next
+    assert_instance_of XML::Node, br
+    assert_equal 'br', br.name
+
+    world = br.next
+    assert_instance_of XML::Node, world
+    assert_equal 'World', world.content
+  end
+
+  def test_libxml_html_parser_context()
+    doc = @xp.parse
+    assert_instance_of(XML::Document, doc)
+    assert_instance_of(XML::Parser::Context, @xp.context)
+  assert @xp.context.html?
+  end
+end # TC_XML_HTMLParser

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