libxml-fixed-jruby 1.0.0-jruby

data/test/tc_properties.rb

@@ -0,0 +1,37 @@
+require "xml"
+require 'test/unit'
+
+# Properties is deprecated - use attributes instead.
+# Tests for backwards compatibility
+
+class TestProperties < Test::Unit::TestCase
+  def setup()
+    xp = XML::Parser.string('<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>')
+    @doc = xp.parse
+  end
+
+  def teardown()
+    @doc = nil
+  end
+
+  def test_traversal
+    properties = @doc.root.properties
+    
+    assert_instance_of(XML::Attributes, properties)
+    # FIXME ordering of Attributes
+    # attribute = properties.first
+    # assert_equal('uga', attribute.name)
+    # assert_equal('booga', attribute.value)
+    # 
+    # attribute = attribute.next
+    # assert_instance_of(XML::Attr, attribute)
+    # assert_equal('foo', attribute.name)
+    # assert_equal('bar', attribute.value)
+  end
+  
+  def test_no_properties
+    properties = @doc.root.child.properties
+    assert_instance_of(XML::Attributes, properties)
+    assert_equal(0, properties.length)
+  end
+end

data/test/tc_reader.rb

@@ -0,0 +1,112 @@
+require 'xml'
+require 'test/unit'
+
+class TC_XML_Reader < Test::Unit::TestCase
+
+  SIMPLE_XML = File.join(File.dirname(__FILE__), 'model/simple.xml')
+
+  def test_new_file
+    reader = XML::Reader.file(SIMPLE_XML)
+    verify_simple(reader)
+    assert_raises(RuntimeError) { XML::Reader.file('/does/not/exist') }
+  end
+
+  def test_new_data
+    reader = XML::Reader.new(File.read(SIMPLE_XML))
+    verify_simple(reader)
+  end
+
+  def test_new_walker
+    reader = XML::Reader.walker(XML::Document.file(SIMPLE_XML))
+    verify_simple(reader)
+  end
+
+  def test_reader_error
+    reader = XML::Reader.new('<foo/>')
+    assert_raises(RuntimeError) { reader.set_error_handler }
+    called = false
+    reader.set_error_handler { |*a| called = true }
+    while reader.read > 0; end
+    assert(!called)
+    reader = XML::Reader.new('<foo blah')
+    reader.set_error_handler do |*a|
+      assert_equal(5, a.size)
+      assert_equal(reader, a[0])
+      assert_equal(XML::Reader::SEVERITY_ERROR, a[2])
+      assert_nil(a[3])
+      assert_equal(1, a[4])
+      called = true
+    end
+    while reader.read > 0; end
+    assert(called)
+  end
+
+  def test_attr
+    parser = XML::Reader.new("<foo x='1' y='2'/>")
+    assert_equal(1, parser.read)
+    assert_equal('foo', parser.name)
+    assert_equal('1', parser['x'])
+    assert_equal('1', parser[0])
+    assert_equal('2', parser['y'])
+    assert_equal('2', parser[1])
+    assert_equal(nil, parser['z'])
+    assert_equal(nil, parser[2])
+  end
+
+  def test_value
+    parser = XML::Reader.new("<foo><bar>1</bar><bar>2</bar><bar>3</bar></foo>")
+    assert_equal(1, parser.read)
+    assert_equal('foo', parser.name)
+    assert_equal(nil, parser.value)
+    3.times do |i|
+      assert_equal(1, parser.read)
+      assert_equal(XML::Reader::TYPE_ELEMENT, parser.node_type)
+      assert_equal('bar', parser.name)
+      assert_equal(1, 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_equal(XML::Reader::TYPE_END_ELEMENT, parser.node_type)
+    end
+  end
+
+  def test_expand
+    reader = XML::Reader.file(SIMPLE_XML)
+    reader.read
+    node = reader.expand
+    doc = node.doc
+    reader.close
+    GC.start
+    
+    doc.standalone?
+  end
+
+  def verify_simple(reader)
+    node_types = []
+    19.times do
+      assert_equal(1, 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])
+  end
+end

data/test/tc_relaxng.rb

@@ -0,0 +1,39 @@
+require "xml"
+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'))
+  end
+  
+  def teardown
+    @doc = nil
+  end
+  
+  def relaxng
+    document = XML::Document.file(File.join(File.dirname(__FILE__), 'model/shiporder.rng'))
+    relaxng = XML::RelaxNG.document(document)
+  end
+
+  def test_from_doc
+    assert_instance_of(XML::RelaxNG, relaxng)
+  end
+  
+  def test_valid
+    assert(@doc.validate_relaxng(relaxng))
+  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_relaxng(relaxng) do |message, error|
+      messages[message] = error
+    end)
+
+    expected = {"Did not expect element invalid there\n" => true}
+    assert_equal(expected, messages)
+  end
+end

data/test/tc_sax_parser.rb

@@ -0,0 +1,113 @@
+require 'xml'
+require 'test/unit'
+
+# TODO this is woefully inadequate
+
+class TestCaseCallbacks
+  include XML::SaxParser::Callbacks
+
+  attr_accessor :test
+
+  def initialize
+    @test = Hash.new { |h,k| h[k] = [] }
+    @i = 0
+  end
+
+  def on_start_document
+    @test[:startdoc] << @i+=1
+  end
+
+  def on_start_element(name, attr_hash)
+    @test[:startel] << [@i+=1,name,attr_hash]
+  end
+
+  def on_characters(chars)
+    @test[:chars] << [@i+=1,chars]
+  end
+
+  def on_comment(msg)
+    @test[:comment] << [@i+=1,msg]
+  end
+
+  def on_processing_instruction(target, data)
+    @test[:pinstr] << [@i+=1, target, data]
+  end
+
+  def on_cdata_block(cdata)
+    @test[:cdata] << [@i+=1,cdata]
+  end
+
+  def on_end_element(name)
+    @test[:endel] << [@i+=1,name]
+  end
+
+  def on_end_document
+    @test[:enddoc] << @i+=1
+  end
+end
+
+class TestSaxParser < Test::Unit::TestCase
+  def setup
+    @xp = XML::SaxParser.new
+  end
+
+  def teardown
+    @xp = nil
+  end
+
+  def verify
+    @xp.parse
+    assert_equal [1], @xp.callbacks.test[:startdoc]
+    assert_equal [[2,'test',{'uga'=>'booga','foo'=>'bar'}],[3,'fixnum',{}],[6,'fixnum',{}]],
+                 @xp.callbacks.test[:startel]
+    assert_equal [[4,'one'],[7,'two'],[9,"\n  "],[11,"\n  "],[13,"\n  "],[15,"\n"]],
+                 @xp.callbacks.test[:chars]
+    assert_equal [[10, ' msg ']], @xp.callbacks.test[:comment]
+    assert_equal [[12, 'custom', 'foo="bar"']], @xp.callbacks.test[:pinstr]
+    assert_equal [[14, 'here it goes']], @xp.callbacks.test[:cdata]
+    assert_equal [[5,'fixnum'],[8,'fixnum'],[16,'test']], @xp.callbacks.test[:endel]
+    assert_equal [17], @xp.callbacks.test[:enddoc]
+  end
+  
+  def test_string_without_callbacks
+    @xp.string = File.read(File.join(File.dirname(__FILE__), 'model/saxtest.xml'))
+    assert_equal true, @xp.parse
+  end
+
+  def test_file_without_callbacks
+    @xp.filename = File.join(File.dirname(__FILE__), 'model/saxtest.xml')
+    assert_equal true, @xp.parse
+  end
+
+  def test_callbacks_with_string
+    @xp.callbacks = TestCaseCallbacks.new
+    @xp.string = File.read(File.join(File.dirname(__FILE__), 'model/saxtest.xml'))
+    verify
+  end
+
+  def test_callbacks_with_file
+    @xp.callbacks = TestCaseCallbacks.new
+    @xp.filename = File.join(File.dirname(__FILE__), 'model/saxtest.xml')
+    verify
+  end
+
+  class DocTypeCallback
+    include XML::SaxParser::Callbacks
+    def on_start_element(element, attributes)
+      puts element
+    end
+  end
+  
+  def test_doctype
+    @xp.callbacks = DocTypeCallback.new
+    @xp.string = <<-EOS
+      <?xml version="1.0" encoding="UTF-8"?>
+      <!DOCTYPE Results SYSTEM "results.dtd">
+      <Results>
+        <a>a1</a>
+      </Results>
+    EOS
+    doc = @xp.parse
+    assert_not_nil(doc)
+  end
+end

data/test/tc_schema.rb

@@ -0,0 +1,39 @@
+require "xml"
+require 'test/unit'
+
+class TestSchema < Test::Unit::TestCase
+  def setup
+    xp = XML::Parser.new
+    @doc = XML::Document.file(File.join(File.dirname(__FILE__), 'model/shiporder.xml'))
+  end
+  
+  def teardown
+    @doc = nil
+  end
+  
+  def schema
+    document = XML::Document.file(File.join(File.dirname(__FILE__), 'model/shiporder.xsd'))
+    schema = XML::Schema.document(document)
+  end
+
+  def test_from_doc
+    assert_instance_of(XML::Schema, schema)
+  end
+  
+  def test_valid
+    assert(@doc.validate_schema(schema))
+  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_schema(schema) do |message, error|
+      messages[message] = error
+    end)
+
+    expected = {"Element 'invalid': This element is not expected. Expected is ( item ).\n" => true}
+    assert_equal(expected, messages)
+  end
+end

data/test/tc_traversal.rb

@@ -0,0 +1,220 @@
+require 'xml'
+require 'test/unit'
+
+class TestTranversal < Test::Unit::TestCase
+  ROOT_NODES_LENGTH = 25
+  ROOT_ELEMENTS_LENGTH = 12
+  
+  def setup
+    filename = File.join(File.dirname(__FILE__), 'model/books.xml')
+    @doc = XML::Document.file(filename)
+  end
+  
+  def teardown
+    @doc = nil
+  end
+  
+  def test_children
+    # Includes text nodes and such
+    assert_equal(ROOT_NODES_LENGTH, @doc.root.children.length)
+  end
+  
+  def test_children_iteration
+    # Includes text nodes and such
+    nodes = @doc.root.children.inject([]) do |arr, node|
+      arr << node
+      arr
+    end
+    
+    assert_equal(ROOT_NODES_LENGTH, nodes.length)
+  end
+  
+  def test_each
+    # Includes text nodes and such
+    nodes = @doc.root.inject([]) do |arr, node|
+      arr << node
+      arr
+    end
+    
+    assert_equal(ROOT_NODES_LENGTH, nodes.length)
+  end
+  
+  def test_each_element
+    # Includes text nodes and such
+    nodes = []
+    @doc.root.each_element do |node|
+      nodes << node
+    end
+    
+    assert_equal(ROOT_ELEMENTS_LENGTH, nodes.length)
+  end
+  
+  def test_next
+    nodes = []
+    
+    node = @doc.root.first
+    
+    while node
+      nodes << node
+      node = node.next
+    end
+    assert_equal(ROOT_NODES_LENGTH, nodes.length)
+  end
+
+  def test_next?
+    first_node = @doc.root.first
+    assert(first_node.next?)
+    
+    last_node = @doc.root.last
+    assert(!last_node.next?)
+  end
+    
+  def test_prev
+    nodes = []
+    
+    node = @doc.root.last
+    
+    while node
+      nodes << node
+      node = node.prev
+    end
+    assert_equal(ROOT_NODES_LENGTH, nodes.length)
+  end
+  
+  def test_prev?
+    first_node = @doc.root.first
+    assert(!first_node.prev?)
+    
+    last_node = @doc.root.last
+    assert(last_node.prev?)
+  end
+
+  def test_parent?
+    assert(!@doc.parent?)
+    assert(@doc.root.parent?)
+  end
+   
+  def test_child?
+    assert(@doc.child?)
+    assert(!@doc.root.first.child?)
+  end
+  
+  def test_next_prev_equivalence
+    next_nodes = []
+    last_nodes = []
+    
+    node = @doc.root.first
+    while node
+      next_nodes << node
+      node = node.next
+    end
+  
+    node = @doc.root.last
+    while node
+      last_nodes << node
+      node = node.prev
+    end
+    
+    assert_equal(next_nodes, last_nodes.reverse)
+  end
+  
+  def test_next_children_equivalence
+    next_nodes = []
+    
+    node = @doc.root.first
+    while node
+      next_nodes << node
+      node = node.next
+    end
+  
+    assert_equal(@doc.root.children, next_nodes)
+  end
+  
+  #    node = @doc.find_first('book')
+   # node.children.each do |node|
+    #  puts 1
+    #end
+   # @doc.root.children do |node|
+    #  if node.node_type == XML::Node::ELEMENT_NODE
+     #   puts node.name
+      #end
+    #end
+    #assert_equal(12,nodes.length)
+  #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_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