libxml-ruby 0.9.8-x86-mswin32-60 → 0.9.9-x86-mswin32-60

data/test/model/definition.dtd

@@ -0,0 +1,8 @@
+<!ELEMENT definition (primary_key|body|reasoning|products)* >
+  <!ATTLIST definition target_entity CDATA #REQUIRED>
+<!ELEMENT primary_key (#PCDATA)>
+  <!ATTLIST primary_key name CDATA #REQUIRED>
+<!ELEMENT body (#PCDATA)>
+<!ELEMENT reasoning (#PCDATA)>
+<!ELEMENT products (product*)>
+<!ENTITY % product SYSTEM "lib/dtds/product.dtd"> %product;

data/test/tc_attributes.rb

@@ -122,9 +122,12 @@ class AttributesTest < Test::Unit::TestCase
     node = @doc.find_first('/city:CityModel/city:cityMember')
     assert_equal(5, node.attributes.length)
 
-    node.attributes.entries.each do |attr|
+    attrs = Array.new
+    node.attributes.each do |attr|
+      attrs << attr
       attr.remove!
     end
+    assert_equal(5, attrs.length)
     assert_equal(0, node.attributes.length)
   end
 end

data/test/tc_document.rb

@@ -83,4 +83,20 @@ class TestDocument < Test::Unit::TestCase
     doc.encoding = XML::Encoding::ISO_8859_1
     assert_equal(XML::Encoding::ISO_8859_1, doc.encoding)
   end
+
+  def test_doc_node_type
+    assert_equal XML::Node::DOCUMENT_NODE, XML::Document.new.node_type
+  end
+
+  def test_doc_node_type_name
+    assert_equal 'document_xml', XML::Document.new.node_type_name
+  end
+
+  def test_xhtml
+		doc = XML::Document.new
+		assert ! doc.xhtml?
+    xhtml_dtd = XML::Dtd.new "-//W3C//DTD XHTML 1.0 Transitional//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", nil, doc, true
+		assert doc.xhtml?
+	end
+  
 end

data/test/tc_dtd.rb

@@ -28,6 +28,34 @@ class TestDtd < Test::Unit::TestCase
     EOS
   end
   
+  def test_internal_subset
+    xhtml_dtd = XML::Dtd.new "-//W3C//DTD XHTML 1.0 Transitional//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", nil, nil, true
+		assert xhtml_dtd.name.nil?
+		assert_equal "-//W3C//DTD XHTML 1.0 Transitional//EN", xhtml_dtd.external_id
+		assert_equal "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", xhtml_dtd.uri
+		assert_equal "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", xhtml_dtd.system_id
+
+    xhtml_dtd = XML::Dtd.new "-//W3C//DTD XHTML 1.0 Transitional//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", "xhtml1", nil, true
+		assert_equal "xhtml1", xhtml_dtd.name
+		assert_equal "-//W3C//DTD XHTML 1.0 Transitional//EN", xhtml_dtd.external_id
+		assert_equal "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", xhtml_dtd.uri
+		assert_equal "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", xhtml_dtd.system_id
+	end
+  
+  def test_external_subset
+    xhtml_dtd = XML::Dtd.new "-//W3C//DTD XHTML 1.0 Transitional//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", nil
+		assert xhtml_dtd.name.nil?
+		assert_equal "-//W3C//DTD XHTML 1.0 Transitional//EN", xhtml_dtd.external_id
+		assert_equal "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", xhtml_dtd.uri
+		assert_equal "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", xhtml_dtd.system_id
+
+    xhtml_dtd = XML::Dtd.new "-//W3C//DTD XHTML 1.0 Transitional//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", "xhtml1"
+		assert_equal "xhtml1", xhtml_dtd.name
+		assert_equal "-//W3C//DTD XHTML 1.0 Transitional//EN", xhtml_dtd.external_id
+		assert_equal "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", xhtml_dtd.uri
+		assert_equal "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", xhtml_dtd.system_id
+	end
+  
   def test_valid
     assert(@doc.validate(dtd))
   end
@@ -44,7 +72,7 @@ class TestDtd < Test::Unit::TestCase
     # Check the error worked
     assert_not_nil(error)
     assert_kind_of(XML::Error, error)
-    assert_equal("Error: No declaration for element invalid at :0.", error.message)
+    assert_equal("Error: No declaration for element invalid.", error.message)
     assert_equal(XML::Error::VALID, error.domain)
     assert_equal(XML::Error::DTD_UNKNOWN_ELEM, error.code)
     assert_equal(XML::Error::ERROR, error.level)
@@ -91,4 +119,4 @@ class TestDtd < Test::Unit::TestCase
   ensure
     XML::Error.reset_handler
   end
-end
+end

data/test/tc_html_parser.rb

@@ -1,4 +1,5 @@
-require "xml"
+require 'xml'
+require 'stringio'
 require 'test/unit'
 
 class HTMLParserTest < Test::Unit::TestCase
@@ -10,29 +11,54 @@ class HTMLParserTest < Test::Unit::TestCase
   def test_file
     xp = XML::HTMLParser.file(html_file)
     assert_instance_of(XML::HTMLParser, xp)
+    doc = xp.parse
+    assert_not_nil(doc)
   end
 
-  def test_string
-    str = '<html><body><p>hi</p></body></html>'
-    xp = XML::HTMLParser.string(str)
+  def test_noexistent_file
+    error = assert_raise(XML::Error) do
+      XML::HTMLParser.file('i_dont_exist.xml')
+    end
 
-    assert_instance_of(XML::HTMLParser, xp)
-    assert_instance_of(XML::HTMLParser, xp)
+    assert_equal('Warning: failed to load external entity "i_dont_exist.xml".', error.to_s)
+  end
 
-    doc = xp.parse
-    assert_instance_of(XML::Document, doc)
+  def test_nil_file
+    error = assert_raise(TypeError) do
+      XML::HTMLParser.file(nil)
+    end
+
+    assert_equal("can't convert nil into String", error.to_s)
   end
 
   def test_io
     File.open(html_file) do |io|
       xp = XML::HTMLParser.io(io)
       assert_instance_of(XML::HTMLParser, xp)
-      
+
       doc = xp.parse
       assert_instance_of(XML::Document, doc)
     end
   end
 
+  def test_io_gc
+    # Test that the reader keeps a reference
+    # to the io object
+    file = File.open(html_file)
+    parser = XML::HTMLParser.io(file)
+    file = nil
+    GC.start
+    assert(parser.parse)
+  end
+
+  def test_nil_io
+    error = assert_raise(TypeError) do
+      XML::HTMLParser.io(nil)
+    end
+
+    assert_equal("Must pass in an IO object", error.to_s)
+  end
+
   def test_string_io
     data = File.read(html_file)
     io = StringIO.new(data)
@@ -43,6 +69,25 @@ class HTMLParserTest < Test::Unit::TestCase
     assert_instance_of(XML::Document, doc)
   end
 
+  def test_string
+    str = '<html><body><p>hi</p></body></html>'
+    xp = XML::HTMLParser.string(str)
+
+    assert_instance_of(XML::HTMLParser, xp)
+    assert_instance_of(XML::HTMLParser, xp)
+
+    doc = xp.parse
+    assert_instance_of(XML::Document, doc)
+  end
+
+  def test_nil_string
+    error = assert_raise(TypeError) do
+      XML::HTMLParser.string(nil)
+    end
+
+    assert_equal("wrong argument type nil (expected String)", error.to_s)
+  end
+
   def test_parse
     html = <<-EOS
       <html>
@@ -90,4 +135,4 @@ class HTMLParserTest < Test::Unit::TestCase
     assert_instance_of XML::Node, world
     assert_equal 'World', world.content
   end
-end
+end

data/test/tc_node.rb

@@ -23,10 +23,18 @@ class TestNode < Test::Unit::TestCase
     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)
@@ -112,4 +120,62 @@ class TestNode < Test::Unit::TestCase
     doc = XML::Parser.string('<person />').parse
     assert_nil(doc.root.base)
   end
-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.
+	#
+	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
+end

data/test/tc_node_edit.rb

@@ -58,13 +58,33 @@ class TestNodeEdit < Test::Unit::TestCase
     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
 
+  def test_remove_node_gc
+    xp = XML::Parser.string('<test><num>one</num><num>two</num><num>three</num></test>')
+    doc = xp.parse
+    node = doc.root.child.remove!
+    node = nil
+    GC.start
+    assert_not_nil(doc)
+  end
+
+  def test_remove_node_iteration
+    nodes = Array.new
+    @doc.root.each_element do |node|
+      if node.name == 'num'
+        nodes << node
+        node.remove!
+      end
+    end
+    assert_equal(3, nodes.length)
+  end
+
   def test_reuse_removed_node
     # Remove the node
     node = @doc.root.first.remove!
@@ -77,7 +97,7 @@ class TestNodeEdit < Test::Unit::TestCase
                  @doc.root.to_s.gsub(/\n\s*/,''))
   end
 
-  # This test is to verify that an earlier reported bug has been fixed  
+  # This test is to verify that an earlier reported bug has been fixed
   def test_merge
     documents = []
 
@@ -90,16 +110,16 @@ class TestNodeEdit < Test::Unit::TestCase
     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('<foo><bar/>bars contents</foo>',
@@ -111,4 +131,4 @@ class TestNodeEdit < Test::Unit::TestCase
     assert_equal("<test xml:base=\"http://www.rubynet.org/\">\n  <num>one</num>\n  <num>two</num>\n  <num>three</num>\n</test>",
                  @doc.root.to_s)
   end
-end
+end

data/test/tc_node_text.rb

@@ -15,23 +15,6 @@ class TestTextNode < Test::Unit::TestCase
     assert_equal('wrong argument type nil (expected String)', error.to_s)
   end
 
-	# Disabling output escaping can't work without this test passing.
-	def test_text_node_name_sanity
-		node = XML::Node.new_text('testdata')
-    assert_equal XML::Node::XML_STRING_TEXT.object_id, node.name.object_id
-    node.name = 'ignore-me'
-    assert_equal XML::Node::XML_STRING_TEXT.object_id, node.name.object_id
-    node.name = XML::Node::XML_STRING_TEXT_NOENC
-    assert_equal XML::Node::XML_STRING_TEXT_NOENC.object_id, node.name.object_id
-    node.name = 'ignore-me'
-    assert_equal XML::Node::XML_STRING_TEXT_NOENC.object_id, node.name.object_id
-  end
-
-	def test_text_node_name_singletons_frozen
-    assert XML::Node::XML_STRING_TEXT.frozen?
-    assert XML::Node::XML_STRING_TEXT_NOENC.frozen?
-  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
@@ -40,12 +23,47 @@ class TestTextNode < Test::Unit::TestCase
 	# to preserve the content of any of the text nodes.
 	#
 	def test_output_escaping
-    node = XML::Node.new_text('<my> "entity"')
-		assert_equal '&lt;my&gt; "entity"', node.to_s
-    node.name = XML::Node::XML_STRING_TEXT_NOENC
-		assert_equal '<my> "entity"', node.to_s
-    node.name = XML::Node::XML_STRING_TEXT
-		assert_equal '&lt;my&gt; "entity"', node.to_s
+		textnoenc = 'if (a < b || c > d) return "e";'
+		text = "if (a &lt; b || c &gt; d) return \"e\";"
+ 
+		node = XML::Node.new_text(textnoenc)
+		assert node.output_escaping?
+		assert_equal text, node.to_s
+
+		node.output_escaping = false
+		assert_equal textnoenc, node.to_s
+
+		node.output_escaping = true
+		assert_equal text, node.to_s
+
+		node.output_escaping = nil
+		assert_equal textnoenc, 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
+		node = XML::Node.new_text('testdata')
+    assert_equal 'text', node.name
+		assert node.output_escaping?
+
+		node.output_escaping = false
+    assert_equal 'textnoenc', node.name
+		assert ! node.output_escaping?
+
+		node.output_escaping = true
+    assert_equal 'text', node.name
+		assert node.output_escaping?
+
+		node.output_escaping = nil
+    assert_equal 'textnoenc', node.name
+		assert ! node.output_escaping?
+
+		node.output_escaping = true
+    assert_equal 'text', node.name
+		assert node.output_escaping?
   end
 
 end

data/test/tc_parser.rb

@@ -27,6 +27,14 @@ class TestParser < Test::Unit::TestCase
     assert_instance_of(XML::Parser::Context, parser.context)
   end
 
+  def test_nil_document
+    error = assert_raise(TypeError) do
+      XML::Parser.document(nil)
+    end
+
+    assert_equal("Must pass an XML::Document object", error.to_s)
+  end
+
   def test_file
     file = File.expand_path(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
 
@@ -36,6 +44,22 @@ class TestParser < Test::Unit::TestCase
     assert_instance_of(XML::Parser::Context, parser.context)
   end
 
+  def test_noexistent_file
+    error = assert_raise(XML::Error) do
+      XML::Parser.file('i_dont_exist.xml')
+    end
+
+    assert_equal('Warning: failed to load external entity "i_dont_exist.xml".', error.to_s)
+  end
+
+  def test_nil_file
+    error = assert_raise(TypeError) do
+      XML::Parser.file(nil)
+    end
+
+    assert_equal("can't convert nil into String", error.to_s)
+  end
+
   def test_file_encoding
     file = File.expand_path(File.join(File.dirname(__FILE__), 'model/bands.xml'))
     parser = XML::Parser.file(file, :encoding => XML::Encoding::ISO_8859_1)
@@ -74,6 +98,24 @@ class TestParser < Test::Unit::TestCase
     end
   end
 
+  def test_io_gc
+    # Test that the reader keeps a reference
+    # to the io object
+    file = File.open(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
+    parser = XML::Parser.io(file)
+    file = nil
+    GC.start
+    assert(parser.parse)
+  end
+
+  def test_nil_io
+    error = assert_raise(TypeError) do
+      XML::Parser.io(nil)
+    end
+
+    assert_equal("Must pass in an IO object", error.to_s)
+  end
+
   def test_string_io
     data = File.read(File.join(File.dirname(__FILE__), 'model/rubynet.xml'))
     string_io = StringIO.new(data)
@@ -95,6 +137,14 @@ class TestParser < Test::Unit::TestCase
     assert_instance_of(XML::Parser::Context, parser.context)
   end
 
+  def test_nil_string
+    error = assert_raise(TypeError) do
+      XML::Parser.string(nil)
+    end
+
+    assert_equal("wrong argument type nil (expected String)", error.to_s)
+  end
+
   def test_string_options
     xml = <<-EOS
       <!DOCTYPE foo [<!ENTITY foo 'bar'>]>