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

data/test/tc_reader.rb

@@ -2,99 +2,127 @@ require 'xml'
 require 'test/unit'
 
 class TestReader < Test::Unit::TestCase
-
-  SIMPLE_XML = File.join(File.dirname(__FILE__), 'model/simple.xml')
+  XML_FILE = File.join(File.dirname(__FILE__), 'model/atom.xml')
 
   def verify_simple(reader)
     node_types = []
-    19.times do
-      assert_equal(1, reader.read)
+    
+    # Read each node
+    26.times do
+      assert(reader.read)
       node_types << reader.node_type
     end
-    assert_equal(0, reader.read)
-    assert_equal(node_types,
-      [XML::Reader::TYPE_ELEMENT,
-       XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
-       XML::Reader::TYPE_ELEMENT,
-       XML::Reader::TYPE_TEXT,
-       XML::Reader::TYPE_END_ELEMENT,
-       XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
-       XML::Reader::TYPE_ELEMENT,
-       XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
-       XML::Reader::TYPE_ELEMENT,
-       XML::Reader::TYPE_TEXT,
-       XML::Reader::TYPE_END_ELEMENT,
-       XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
-       XML::Reader::TYPE_ELEMENT,
-       XML::Reader::TYPE_TEXT,
-       XML::Reader::TYPE_END_ELEMENT,
-       XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
-       XML::Reader::TYPE_END_ELEMENT,
-       XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
-       XML::Reader::TYPE_END_ELEMENT])
+
+    # There are no more nodes
+    assert(!reader.read)
+
+    # Check what was read
+    expected = [XML::Reader::TYPE_PROCESSING_INSTRUCTION,
+                XML::Reader::TYPE_ELEMENT,
+                XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
+                XML::Reader::TYPE_COMMENT,
+                XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
+                XML::Reader::TYPE_ELEMENT,
+                XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
+                XML::Reader::TYPE_ELEMENT,
+                XML::Reader::TYPE_CDATA,
+                XML::Reader::TYPE_END_ELEMENT,
+                XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
+                XML::Reader::TYPE_ELEMENT,
+                XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
+                XML::Reader::TYPE_ELEMENT,
+                XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
+                XML::Reader::TYPE_ELEMENT,
+                XML::Reader::TYPE_TEXT,
+                XML::Reader::TYPE_END_ELEMENT,
+                XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
+                XML::Reader::TYPE_END_ELEMENT,
+                XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
+                XML::Reader::TYPE_END_ELEMENT,
+                XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
+                XML::Reader::TYPE_END_ELEMENT,
+                XML::Reader::TYPE_SIGNIFICANT_WHITESPACE,
+                XML::Reader::TYPE_END_ELEMENT]
+
+    assert_equal(expected, node_types)
+  end
+
+  def test_document
+    reader = XML::Reader.document(XML::Document.file(XML_FILE))
+    verify_simple(reader)
   end
 
   def test_file
-    reader = XML::Reader.file(SIMPLE_XML)
+    reader = XML::Reader.file(XML_FILE)
     verify_simple(reader)
   end
 
   def test_invalid_file
-    assert_raises(XML::Error) do
+    assert_raise(XML::Error) do
       XML::Reader.file('/does/not/exist')
     end
   end
 
   def test_string
-    reader = XML::Reader.string(File.read(SIMPLE_XML))
+    reader = XML::Reader.string(File.read(XML_FILE))
     verify_simple(reader)
   end
 
   def test_io
-    File.open(SIMPLE_XML, 'rb') do |io|
+    File.open(XML_FILE, 'rb') do |io|
       reader = XML::Reader.io(io)
       verify_simple(reader)
     end
   end
 
   def test_string_io
-    data = File.read(SIMPLE_XML)
+    data = File.read(XML_FILE)
     string_io = StringIO.new(data)
     reader = XML::Reader.io(string_io)
     verify_simple(reader)
   end
 
-  def test_new_walker
-    reader = XML::Reader.walker(XML::Document.file(SIMPLE_XML))
-    verify_simple(reader)
+  def test_error
+    reader = XML::Reader.string('<foo blah')
+
+    error = assert_raise(XML::Error) do
+      reader.read
+    end
+    assert_equal("Fatal error: Couldn't find end of Start Tag foo at :1.", error.to_s)
   end
 
   def test_deprecated_error_handler
     called = false
-    reader = XML::Reader.new('<foo blah')
+    reader = XML::Reader.string('<foo blah')
     reader.set_error_handler do |error|
       called = true
     end
 
-    reader.read
+    assert_raise(XML::Error) do
+      reader.read
+    end
+
     assert(called)
   end
 
   def test_deprecated_reset_error_handler
     called = false
-    reader = XML::Reader.new('<foo blah')
+    reader = XML::Reader.string('<foo blah')
     reader.set_error_handler do |error|
       called = true
     end
     reader.reset_error_handler
 
-    reader.read
+    assert_raise(XML::Error) do
+      reader.read
+    end
+
     assert(!called)
   end
 
   def test_attr
-    parser = XML::Reader.new("<foo x='1' y='2'/>")
-    assert_equal(1, parser.read)
+    parser = XML::Reader.string("<foo x='1' y='2'/>")
+    assert(parser.read)
     assert_equal('foo', parser.name)
     assert_equal('1', parser['x'])
     assert_equal('1', parser[0])
@@ -105,24 +133,24 @@ class TestReader < Test::Unit::TestCase
   end
 
   def test_value
-    parser = XML::Reader.new("<foo><bar>1</bar><bar>2</bar><bar>3</bar></foo>")
-    assert_equal(1, parser.read)
+    parser = XML::Reader.string("<foo><bar>1</bar><bar>2</bar><bar>3</bar></foo>")
+    assert(parser.read)
     assert_equal('foo', parser.name)
     assert_equal(nil, parser.value)
     3.times do |i|
-      assert_equal(1, parser.read)
+      assert(parser.read)
       assert_equal(XML::Reader::TYPE_ELEMENT, parser.node_type)
       assert_equal('bar', parser.name)
-      assert_equal(1, parser.read)
+      assert(parser.read)
       assert_equal(XML::Reader::TYPE_TEXT, parser.node_type)
       assert_equal((i + 1).to_s, parser.value)
-      assert_equal(1, parser.read)
+      assert(parser.read)
       assert_equal(XML::Reader::TYPE_END_ELEMENT, parser.node_type)
     end
   end
 
   def test_expand
-    reader = XML::Reader.file(SIMPLE_XML)
+    reader = XML::Reader.file(XML_FILE)
     reader.read
     node = reader.expand
     doc = node.doc
@@ -138,4 +166,104 @@ class TestReader < Test::Unit::TestCase
     reader.read
     assert_equal(XML::Reader::MODE_EOF, reader.read_state)
   end
+
+  def test_bytes_consumed
+    reader = XML::Reader.file(XML_FILE)
+    reader.read
+    assert_equal(416, reader.byte_consumed)
+  end
+
+  def test_node
+    XML.default_line_numbers = true
+    reader = XML::Reader.file(XML_FILE)
+    reader.read
+    assert_instance_of(XML::Node, reader.node)
+  end
+
+  def test_base_uri
+    # UTF8:
+    # ö - c3 b6 in hex, \303\266 in octal
+    # ü - c3 bc in hex, \303\274 in octal
+    xml = "<bands genre=\"metal\">\n  <m\303\266tley_cr\303\274e country=\"us\">An American heavy metal band formed in Los Angeles, California in 1981.</m\303\266tley_cr\303\274e>\n  <iron_maiden country=\"uk\">British heavy metal band formed in 1975.</iron_maiden>\n</bands>"
+    reader = XML::Reader.string(xml, :base_uri => "http://libxml.rubyforge.org")
+
+    reader.read
+    assert_equal(reader.base_uri, "http://libxml.rubyforge.org")
+  end
+
+  def test_options
+    xml = <<-EOS
+      <!DOCTYPE foo [<!ENTITY foo 'bar'>]>
+      <test>
+        <cdata><![CDATA[something]]></cdata>
+        <entity>&foo;</entity>
+      </test>
+    EOS
+
+    # Parse normally
+    reader = XML::Reader.string(xml)
+    reader.read # foo
+    reader.read # test
+    reader.read # text
+    reader.read # cdata
+    reader.read # cdata-section
+    assert_equal(XML::Node::CDATA_SECTION_NODE, reader.node_type)
+
+    # Convert cdata section to text
+    reader = XML::Reader.string(xml, :options => XML::Parser::Options::NOCDATA)
+    reader.read # foo
+    reader.read # test
+    reader.read # text
+    reader.read # cdata
+    reader.read # cdata-section
+    assert_equal(XML::Node::TEXT_NODE, reader.node_type)
+  end
+
+  def test_encoding
+    # ISO_8859_1:
+    # ö - f6 in hex, \366 in octal
+    # ü - fc in hex, \374 in octal
+    xml = "<bands genre=\"metal\">\n  <m\366tley_cr\374e country=\"us\">An American heavy metal band formed in Los Angeles, California in 1981.</m\366tley_cr\374e>\n  <iron_maiden country=\"uk\">British heavy metal band formed in 1975.</iron_maiden>\n</bands>"
+
+    reader = XML::Reader.string(xml, :encoding => XML::Encoding::ISO_8859_1)
+    reader.read
+
+    # libxml converts all data sources to utf8 internally
+    assert_equal("<bands genre=\"metal\">\n  <m\303\266tley_cr\303\274e country=\"us\">An American heavy metal band formed in Los Angeles, California in 1981.</m\303\266tley_cr\303\274e>\n  <iron_maiden country=\"uk\">British heavy metal band formed in 1975.</iron_maiden>\n</bands>",
+                     reader.read_outer_xml)
+  end
+
+  def test_invalid_encoding
+    # ISO_8859_1:
+    # ö - f6 in hex, \366 in octal
+    # ü - fc in hex, \374 in octal
+    xml = "<bands genre=\"metal\">\n  <m\366tley_cr\374e country=\"us\">An American heavy metal band formed in Los Angeles, California in 1981.</m\366tley_cr\374e>\n  <iron_maiden country=\"uk\">British heavy metal band formed in 1975.</iron_maiden>\n</bands>"
+
+    reader = XML::Reader.string(xml)
+    error = assert_raise(XML::Error) do
+      node = reader.read
+    end
+
+    assert_equal("Fatal error: Input is not proper UTF-8, indicate encoding !\nBytes: 0xF6 0x74 0x6C 0x65 at :2.",
+                 error.to_s)
+
+  end
+
+  def test_file_encoding
+    reader = XML::Reader.file(XML_FILE)
+    reader.read
+    assert_equal(reader.encoding, XML::Encoding::UTF_8)
+  end
+
+  def test_string_encoding
+    # ISO_8859_1:
+    # ö - f6 in hex, \366 in octal
+    # ü - fc in hex, \374 in octal
+    xml = "<bands genre=\"metal\">\n  <m\366tley_cr\374e country=\"us\">An American heavy metal band formed in Los Angeles, California in 1981.</m\366tley_cr\374e>\n  <iron_maiden country=\"uk\">British heavy metal band formed in 1975.</iron_maiden>\n</bands>"
+    reader = XML::Reader.string(xml, :encoding => XML::Encoding::ISO_8859_1)
+    reader.read
+
+    # Encoding is always null for strings, very annoying!
+    assert_equal(reader.encoding, XML::Encoding::NONE)
+  end
 end

data/test/tc_relaxng.rb

@@ -3,8 +3,8 @@ require 'test/unit'
 
 class TestRelaxNG < Test::Unit::TestCase
   def setup
-    xp = XML::Parser.new
-    @doc = XML::Document.file(File.join(File.dirname(__FILE__), 'model/shiporder.xml'))
+    file = File.join(File.dirname(__FILE__), 'model/shiporder.xml')
+    @doc = XML::Document.file(file)
   end
   
   def teardown

data/test/tc_sax_parser.rb

@@ -67,22 +67,12 @@ class TestCaseCallbacks
 end
 
 class TestSaxParser < Test::Unit::TestCase
-  def setup
-    XML.default_keep_blanks = true
-    @xp = XML::SaxParser.new
-  end
-
-  def teardown
-    @xp = nil
-    XML.default_keep_blanks = true
-  end
-
   def saxtest_file
     File.join(File.dirname(__FILE__), 'model/atom.xml')
   end
 
-  def verify
-    result = @xp.callbacks.result
+  def verify(parser)
+    result = parser.callbacks.result
 
     i = -1
     assert_equal("startdoc", result[i+=1])
@@ -127,75 +117,80 @@ class TestSaxParser < Test::Unit::TestCase
     assert_equal("end_document", result[i+=1])
   end
 
-  def test_string_no_callbacks
-    @xp.string = File.read(saxtest_file)
-    assert_equal true, @xp.parse
+  def test_file
+    parser = XML::SaxParser.file(saxtest_file)
+    parser.callbacks = TestCaseCallbacks.new
+    parser.parse
+    verify(parser)
   end
 
   def test_file_no_callbacks
-    @xp.file = File.join(saxtest_file)
-    assert_equal true, @xp.parse
+    parser = XML::SaxParser.file(saxtest_file)
+    assert_equal true, parser.parse
   end
 
-  def test_string
-    @xp.callbacks = TestCaseCallbacks.new
-    @xp.string = File.read(saxtest_file)
-    @xp.parse
-    verify
+  def test_io
+    File.open(saxtest_file) do |file|
+      parser = XML::SaxParser.io(file)
+      parser.callbacks = TestCaseCallbacks.new
+      parser.parse
+      verify(parser)
+    end
   end
 
-  def test_file
-    @xp.callbacks = TestCaseCallbacks.new
-    @xp.file = saxtest_file
-    @xp.parse
-    verify
+  def test_string_no_callbacks
+    xml = File.read(saxtest_file)
+    parser = XML::SaxParser.string(xml)
+    assert_equal true, parser.parse
   end
 
-  def test_io
-    File.open(saxtest_file) do |file|
-      @xp.callbacks = TestCaseCallbacks.new
-      @xp.io = file
-      @xp.parse
-      verify
-    end
+  def test_string
+    xml = File.read(saxtest_file)
+    parser = XML::SaxParser.string(xml)
+    parser.callbacks = TestCaseCallbacks.new
+    parser.parse
+    verify(parser)
   end
 
   def test_string_io
-    data = File.read(saxtest_file)
-
-    @xp.callbacks = TestCaseCallbacks.new
-    @xp.io = StringIO.new(data)
-    @xp.parse
-    verify
+    xml = File.read(saxtest_file)
+    io = StringIO.new(xml)
+    parser = XML::SaxParser.io(io)
+    
+    parser.callbacks = TestCaseCallbacks.new
+    parser.parse
+    verify(parser)
   end
 
   def test_doctype
-    @xp.callbacks = DocTypeCallback.new
-    @xp.string = <<-EOS
+    xml = <<-EOS
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE Results SYSTEM "results.dtd">
 <Results>
   <a>a1</a>
 </Results>
 EOS
-    doc = @xp.parse
+    parser = XML::SaxParser.string(xml)
+    parser.callbacks = DocTypeCallback.new
+    doc = parser.parse
     assert_not_nil(doc)
   end
 
-
   def test_parse_warning
-    @xp.callbacks = TestCaseCallbacks.new
     # Two xml PIs is a warning
-    @xp.string = <<-EOS
+    xml = <<-EOS
 <?xml version="1.0" encoding="utf-8"?>
 <?xml-invalid?>
 <Test/>
 EOS
 
-    @xp.parse
+    parser = XML::SaxParser.string(xml)
+    parser.callbacks = TestCaseCallbacks.new
+
+    parser.parse
 
     # Check callbacks
-    result = @xp.callbacks.result
+    result = parser.callbacks.result
     i = -1
     assert_equal("startdoc", result[i+=1])
     assert_equal("error: Warning: xmlParsePITarget: invalid name prefix 'xml' at :2.", result[i+=1])
@@ -208,17 +203,18 @@ EOS
   end
 
   def test_parse_error
-    @xp.callbacks = TestCaseCallbacks.new
-    @xp.string = <<-EOS
+    xml = <<-EOS
       <Results>
     EOS
+    parser = XML::SaxParser.string(xml)
+    parser.callbacks = TestCaseCallbacks.new
 
     error = assert_raise(XML::Error) do
-      doc = @xp.parse
+      doc = parser.parse
     end
 
     # Check callbacks
-    result = @xp.callbacks.result
+    result = parser.callbacks.result
 
     i = -1
     assert_equal("startdoc", result[i+=1])