smile-xml 1.0.0-jruby → 1.0.2-jruby

data/src/test/ruby/tc_namespaces.rb

@@ -0,0 +1,210 @@
+# encoding: UTF-8
+
+require './test_helper'
+
+require 'test/unit'
+
+class TestNamespaces < Test::Unit::TestCase
+  def setup
+    file = File.join(File.dirname(__FILE__), 'model/soap.xml')
+    @doc = XML::Document.file(file)
+  end
+
+  def teardown
+    @doc = nil
+  end
+
+  def test_namespace_node
+    node = @doc.root
+    ns = node.namespaces.namespace
+    assert_equal('soap', ns.prefix)
+    assert_equal('http://schemas.xmlsoap.org/soap/envelope/', ns.href)
+  end
+
+  def test_namespace_attr
+    node = @doc.root
+    attr = node.attributes.get_attribute('encodingStyle')
+    assert_equal('soap', attr.ns.prefix)
+    assert_equal('soap', attr.namespaces.namespace.prefix)
+  end
+
+  def test_set_namespace_node
+    node = XML::Node.new('Envelope')
+    assert_equal('<Envelope/>', node.to_s)
+
+    ns = XML::Namespace.new(node, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
+    assert_equal("<Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\"/>", node.to_s)
+    assert_nil(node.namespaces.namespace)
+
+    # Now put the node in the soap namespace
+    node.namespaces.namespace = ns
+    assert_not_nil(node.namespaces.namespace)
+    assert_equal("<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\"/>", node.to_s)
+  end
+
+  def test_set_namespace_attribute
+    # Create node
+    node = XML::Node.new('Envelope')
+    assert_equal('<Envelope/>', node.to_s)
+
+    # Create attribute
+    attr = XML::Attr.new(node, "encodingStyle", "http://www.w3.org/2001/12/soap-encoding")
+    assert_equal('<Envelope encodingStyle="http://www.w3.org/2001/12/soap-encoding"/>',
+                 node.to_s)
+
+    # Create namespace attribute
+    ns = XML::Namespace.new(node, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
+    assert_equal('<Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" encodingStyle="http://www.w3.org/2001/12/soap-encoding"/>',
+                  node.to_s)
+    assert_nil(node.namespaces.namespace)
+
+    # Now put the node in the soap namespace
+    node.namespaces.namespace = ns
+    assert_not_nil(node.namespaces.namespace)
+    assert_equal('<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" encodingStyle="http://www.w3.org/2001/12/soap-encoding"/>',
+                  node.to_s)
+
+    # Now put the attribute in the soap namespace
+    attr.namespaces.namespace = ns
+    assert_not_nil(node.namespaces.namespace)
+    assert_equal('<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" soap:encodingStyle="http://www.w3.org/2001/12/soap-encoding"/>',
+                  node.to_s)
+  end
+
+  def test_define_namespace
+    node = XML::Node.new('Envelope')
+    assert_equal('<Envelope/>', node.to_s)
+
+    XML::Namespace.new(node, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
+    assert_equal("<Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\"/>", node.to_s)
+    assert_nil(node.namespaces.namespace)
+  end
+
+  def test_define_default_namespace
+    node = XML::Node.new('Envelope')
+    assert_equal('<Envelope/>', node.to_s)
+
+    XML::Namespace.new(node, nil, 'http://schemas.xmlsoap.org/soap/envelope/')
+    assert_equal("<Envelope xmlns=\"http://schemas.xmlsoap.org/soap/envelope/\"/>", node.to_s)
+    # This seems wrong, but appears to be the way libxml works
+    assert_nil(node.namespaces.namespace)
+  end
+
+  def test_namespaces
+    node = @doc.find_first('//ns1:IdAndName',
+                           :ns1 => 'http://domain.somewhere.com')
+
+    namespaces = node.namespaces.sort
+    assert_equal(5, namespaces.length)
+
+    namespace = namespaces[0]
+    assert_instance_of(XML::Namespace, namespace)
+    assert_equal(nil, namespace.prefix)
+    assert_equal('http://services.somewhere.com', namespace.href)
+
+    namespace = namespaces[1]
+    assert_instance_of(XML::Namespace, namespace)
+    assert_equal('ns1', namespace.prefix)
+    assert_equal('http://domain.somewhere.com', namespace.href)
+
+    namespace = namespaces[2]
+    assert_instance_of(XML::Namespace, namespace)
+    assert_equal('soap', namespace.prefix)
+    assert_equal('http://schemas.xmlsoap.org/soap/envelope/', namespace.href)
+
+    namespace = namespaces[3]
+    assert_instance_of(XML::Namespace, namespace)
+    assert_equal('xsd', namespace.prefix)
+    assert_equal('http://www.w3.org/2001/XMLSchema', namespace.href)
+
+    namespace = namespaces[4]
+    assert_instance_of(XML::Namespace, namespace)
+    assert_equal('xsi', namespace.prefix)
+    assert_equal('http://www.w3.org/2001/XMLSchema-instance', namespace.href)
+  end
+
+  def test_namespaces
+    node = @doc.find_first('//ns1:IdAndName',
+                           :ns1 => 'http://domain.somewhere.com')
+
+    node.namespaces.each do |namespace|
+      assert_instance_of(XML::Namespace, namespace)
+    end
+  end
+
+  def test_namespace_definitions
+    ns_defs = @doc.root.namespaces.definitions
+    assert_equal(3, ns_defs.size)
+
+    namespace = ns_defs[0]
+    assert_instance_of(XML::Namespace, namespace)
+    assert_equal('soap', namespace.prefix)
+    assert_equal('http://schemas.xmlsoap.org/soap/envelope/', namespace.href)
+
+    namespace = ns_defs[1]
+    assert_instance_of(XML::Namespace, namespace)
+    assert_equal('xsd', namespace.prefix)
+    assert_equal('http://www.w3.org/2001/XMLSchema', namespace.href)
+
+    namespace = ns_defs[2]
+    assert_instance_of(XML::Namespace, namespace)
+    assert_equal('xsi', namespace.prefix)
+    assert_equal('http://www.w3.org/2001/XMLSchema-instance', namespace.href)
+
+    node = @doc.root.find_first('//ns:getManufacturerNamesResponse',
+                                :ns => 'http://services.somewhere.com')
+    ns_defs = node.namespaces.definitions
+    assert_equal(1, ns_defs.size)
+
+    namespace = ns_defs[0]
+    assert_instance_of(XML::Namespace, namespace)
+    assert_equal(nil, namespace.prefix)
+    assert_equal('http://services.somewhere.com', namespace.href)
+  end
+
+  def test_find_by_prefix
+    namespace = @doc.root.namespaces.find_by_prefix('soap')
+
+    assert_instance_of(XML::Namespace, namespace)
+    assert_equal('soap', namespace.prefix)
+    assert_equal('http://schemas.xmlsoap.org/soap/envelope/', namespace.href)
+  end
+
+  def test_find_default_ns
+    namespace = @doc.root.namespaces.find_by_prefix(nil)
+    assert_nil(namespace)
+
+    node = @doc.find_first('//ns1:getManufacturerNamesResponse',
+                           :ns1 => 'http://services.somewhere.com')
+    namespace = node.namespaces.find_by_prefix(nil)
+
+    assert_instance_of(XML::Namespace, namespace)
+    assert_equal(nil, namespace.prefix)
+    assert_equal('http://services.somewhere.com', namespace.href)
+  end
+
+  def test_find_ns_by_href
+    node = @doc.find_first('//ns1:getManufacturerNamesResponse',
+                           :ns1 => 'http://services.somewhere.com')
+
+    namespace = node.namespaces.find_by_href('http://schemas.xmlsoap.org/soap/envelope/')
+
+    assert_instance_of(XML::Namespace, namespace)
+    assert_equal('soap', namespace.prefix)
+    assert_equal('http://schemas.xmlsoap.org/soap/envelope/', namespace.href)
+  end
+
+  def test_default_namespace
+    doc = XML::Document.string('<Envelope xmlns="http://schemas.xmlsoap.org/soap/envelope/"/>')
+    ns = doc.root.namespaces.default
+    assert_equal(ns.href, 'http://schemas.xmlsoap.org/soap/envelope/')
+  end
+
+  def test_default_prefix
+    doc = XML::Document.string('<Envelope xmlns="http://schemas.xmlsoap.org/soap/envelope/"/>')
+    doc.root.namespaces.default_prefix = 'soap'
+
+    node = doc.root.find_first('/soap:Envelope')
+    assert_not_nil(node)
+  end
+end

data/src/test/ruby/tc_node.rb

@@ -0,0 +1,273 @@
+# encoding: UTF-8
+
+require './test_helper'
+require 'test/unit'
+
+class TestNode < Test::Unit::TestCase
+  def setup
+    load_encoding("utf-8")
+  end
+  
+  def teardown
+    XML.default_keep_blanks = true
+    @doc = nil
+  end
+
+  def load_encoding(name)
+    @encoding = Encoding.find(name) if defined?(Encoding)
+    @file_name = "model/bands.#{name.downcase}.xml"
+
+    # Strip spaces to make testing easier
+    XML.default_keep_blanks = false
+    file = File.join(File.dirname(__FILE__), @file_name)
+    @doc = XML::Document.file(file)
+  end
+
+  def nodes
+    # Find all nodes with a country attributes
+    @doc.find('//*[@country]')
+  end
+
+  def test_doc_class
+    assert_instance_of(XML::Document, @doc)
+  end
+
+  def test_doc_node_type
+    assert_equal XML::Node::DOCUMENT_NODE, @doc.node_type
+  end
+
+  def test_root_class
+    assert_instance_of(XML::Node, @doc.root)
+  end
+
+  def test_root_node_type
+    assert_equal XML::Node::ELEMENT_NODE, @doc.root.node_type
+  end
+
+  def test_node_class
+    for n in nodes
+      assert_instance_of(XML::Node, n)
+    end
+  end
+
+  def test_context
+    node = @doc.root
+    context = node.context
+    assert_instance_of(XML::XPath::Context, context)
+  end
+
+  def test_find
+    assert_instance_of(XML::XPath::Object, self.nodes)
+  end
+
+  def test_node_child_get
+    assert_instance_of(TrueClass, @doc.root.child?)
+    assert_instance_of(XML::Node, @doc.root.child)
+
+    if defined?(Encoding)
+      assert_equal(@encoding, @doc.root.child.name.encoding)
+      assert_equal("m\u00F6tley_cr\u00FCe", @doc.root.child.name)
+    else
+      assert_equal("m\303\266tley_cr\303\274e", @doc.root.child.name)
+    end
+  end
+
+  def test_node_doc
+    for n in nodes
+      assert_instance_of(XML::Document, n.doc) if n.document?
+    end
+  end
+
+  def test_name
+    #assert_equal("m\303\266tley_cr\303\274e", )
+    if defined?(Encoding)
+      assert_equal(@encoding, nodes[0].name.encoding)
+      assert_equal("m\u00F6tley_cr\u00FCe", nodes[0].name)
+    else
+      assert_equal("m\303\266tley_cr\303\274e", nodes[0].name)
+    end
+    assert_equal("iron_maiden", nodes[1].name)
+  end
+
+  def test_name_iso_8859_1
+    load_encoding("iso-8859-1")
+    
+    if defined?(Encoding)
+      assert_equal(@encoding, nodes[0].name.encoding)
+      assert_equal("m\303\266tley_cr\303\274e".force_encoding(@encoding), nodes[0].name)
+    else
+      assert_equal("m\303\266tley_cr\303\274e", nodes[0].name)
+    end
+    assert_equal("iron_maiden", nodes[1].name)
+  end
+
+  def test_node_find
+    nodes = @doc.root.find('./fixnum')
+    for node in nodes
+      assert_instance_of(XML::Node, node)
+    end
+  end
+
+  def test_equality
+    node_a = @doc.find_first('//*[@country]')
+    node_b = @doc.root.child
+
+    assert(node_a == node_b)
+    assert(node_a.eql?(node_b))
+    assert(node_a.equal?(node_b))
+
+    file = File.join(File.dirname(__FILE__), @file_name)
+    doc2 = XML::Document.file(file)
+
+    node_a2 = doc2.find_first('//*[@country]')
+
+    assert_equal(node_a.to_s, node_a2.to_s)
+    assert_equal(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_raise(TypeError) do
+      assert(node != 'abc')
+    end
+  end
+
+  def test_content
+    if defined?(Encoding)
+      assert_equal(@encoding, @doc.root.content.encoding)
+      assert_equal("M\u00F6tley Cr\u00FCe is an American heavy metal band formed in Los Angeles, California in 1981.Iron Maiden is a British heavy metal band formed in 1975.",
+                   @doc.root.content)
+
+      first = @doc.root.child
+      assert_equal("M\u00F6tley Cr\u00FCe is an American heavy metal band formed in Los Angeles, California in 1981.",
+                   first.content)
+      assert_equal("Iron Maiden is a British heavy metal band formed in 1975.", first.next.content)
+    else
+      assert_equal("M\303\266tley Cr\303\274e is an American heavy metal band formed in Los Angeles, California in 1981.Iron Maiden is a British heavy metal band formed in 1975.",
+      @doc.root.content.split("\n").map{|t| t.strip }.join )
+
+      first = @doc.root.child
+      assert_equal("M\303\266tley Cr\303\274e is an American heavy metal band formed in Los Angeles, California in 1981.",
+                   first.content)
+      assert_equal("Iron Maiden is a British heavy metal band formed in 1975.",
+                   first.next.content)
+    end
+  end
+
+  def test_content_iso_8859_1
+    load_encoding("iso-8859-1")
+    if defined?(Encoding)
+      assert_equal(@encoding, @doc.root.content.encoding)
+      assert_equal("M\xC3\xB6tley Cr\xC3\xBCe is an American heavy metal band formed in Los Angeles, California in 1981.Iron Maiden is a British heavy metal band formed in 1975.".force_encoding(@encoding),
+                   @doc.root.content)
+
+      first = @doc.root.child
+      assert_equal("M\xC3\xB6tley Cr\xC3\xBCe is an American heavy metal band formed in Los Angeles, California in 1981.".force_encoding(@encoding),
+                   first.content)
+      assert_equal("Iron Maiden is a British heavy metal band formed in 1975.", first.next.content)
+    else
+      assert_equal("M\303\266tley Cr\303\274e is an American heavy metal band formed in Los Angeles, California in 1981.Iron Maiden is a British heavy metal band formed in 1975.",
+                   @doc.root.content.split("\n").map{|t| t.strip }.join )
+
+      first = @doc.root.child
+      assert_equal("M\303\266tley Cr\303\274e is an American heavy metal band formed in Los Angeles, California in 1981.",
+                   first.content)
+      assert_equal("Iron Maiden is a British heavy metal band formed in 1975.", first.next.content)
+    end
+  end
+
+  def test_base
+    doc = XML::Parser.string('<person />').parse
+    assert_nil(doc.root.base_uri)
+  end
+
+	# We use the same facility that libXSLT does here to disable output escaping.
+	# This lets you specify that the node's content should be rendered unaltered
+	# whenever it is being output.  This is useful for things like <script> and
+	# <style> nodes in HTML documents if you don't want to be forced to wrap them
+	# in CDATA nodes.  Or if you are sanitizing existing HTML documents and want
+	# to preserve the content of any of the text nodes.
+	#
+# TODO   
+#	def test_output_escaping
+#		text = '<bad-script>if (a &lt; b || b &gt; c) { return "text"; }<stop/>return "&gt;&gt;&gt;snip&lt;&lt;&lt;";</bad-script>'
+#    node = XML::Parser.string(text).parse.root
+#		assert_equal text, node.to_s
+#
+#		text_noenc = '<bad-script>if (a < b || b > c) { return "text"; }<stop/>return ">>>snip<<<";</bad-script>'
+#		node.output_escaping = false
+#		assert_equal text_noenc, node.to_s
+#
+#		node.output_escaping = true
+#		assert_equal text, node.to_s
+#
+#		node.output_escaping = nil
+#		assert_equal text_noenc, node.to_s
+#
+#		node.output_escaping = true
+#		assert_equal text, node.to_s
+#  end
+#  
+#	# Just a sanity check for output escaping.
+#	def test_output_escaping_sanity
+#		text = '<bad-script>if (a &lt; b || b &gt; c) { return "text"; }<stop/>return "&gt;&gt;&gt;snip&lt;&lt;&lt;";</bad-script>'
+#    node = XML::Parser.string(text).parse.root
+#		affected = node.find('//text()')
+#
+#		check_escaping = lambda do |flag|
+#			assert_equal('bad-script', node.name)
+#			assert_equal(flag, node.output_escaping?)
+#			affected.each do |x|
+#				assert_equal(flag ? 'text' : 'textnoenc', x.name)
+#				assert_equal(flag, x.output_escaping?)
+#			end
+#		end
+#
+#		node.output_escaping = false
+#		check_escaping[false]
+#
+#		node.output_escaping = true
+#		check_escaping[true]
+#
+#		node.output_escaping = nil
+#		check_escaping[false]
+#
+#		node.output_escaping = true
+#		check_escaping[true]
+#
+#		affected.first.output_escaping = true
+#		affected.last.output_escaping = false
+#		assert node.output_escaping?.nil?
+#  end
+
+  def test_space_preserve
+    node = @doc.root
+
+    node.space_preserve = false
+    assert_equal XML::Node::SPACE_DEFAULT, node.space_preserve
+
+    node.space_preserve = true
+    assert_equal XML::Node::SPACE_PRESERVE, node.space_preserve
+  end
+
+  def test_empty
+    text = '<name> </name>'
+    doc = XML::Parser.string(text).parse
+
+    node = doc.root
+    assert(!node.empty?)
+    
+    text_node = node.first
+    # TODO first node is nil 
+    # assert(text_node.empty?)
+  end
+  
+end

data/src/test/ruby/tc_node_cdata.rb

@@ -0,0 +1,51 @@
+# encoding: UTF-8
+
+require './test_helper'
+require 'test/unit'
+
+class CDataCommentTest < Test::Unit::TestCase
+  def setup
+    xp = XML::Parser.string('<root></root>')
+    @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/src/test/ruby/tc_node_comment.rb

@@ -0,0 +1,33 @@
+# encoding: UTF-8
+
+require './test_helper'
+
+require 'test/unit'
+
+class NodeCommentTest < Test::Unit::TestCase
+  def setup
+    xp = XML::Parser.string('<root></root>')
+    @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/src/test/ruby/tc_node_copy.rb

@@ -0,0 +1,42 @@
+# encoding: UTF-8
+
+require './test_helper'
+require 'test/unit'
+
+# see mailing list archive
+# [libxml-devel] Segmentation fault when add the cloned/copied node
+# 2007/11/27 20:51
+
+class TestNodeCopy < 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 << c
+    end
+    assert @div1.to_s =~ /foo/
+  end
+
+  def test_libxml_node_clone_not_segv
+    @div2.each do |child|
+      c = child.clone
+      @div1 << c
+    end
+    assert @div1.to_s =~ /foo/
+  end
+
+end # TC_XML_Node_Copy