libxml-ruby 2.0.0-x86-mingw32

data/test/tc_schema.rb

@@ -0,0 +1,53 @@
+# encoding: UTF-8
+
+require './test_helper'
+require 'test/unit'
+
+class TestSchema < Test::Unit::TestCase
+  def setup
+    file = File.join(File.dirname(__FILE__), 'model/shiporder.xml')
+    @doc = XML::Document.file(file)
+  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 << new_node
+
+    error = assert_raise(XML::Error) do
+      @doc.validate_schema(schema)
+    end
+
+    assert_not_nil(error)
+    assert_kind_of(XML::Error, error)
+    assert(error.message.match(/Error: Element 'invalid': This element is not expected. Expected is \( item \)/))
+    assert_equal(XML::Error::SCHEMASV, error.domain)
+    assert_equal(XML::Error::SCHEMAV_ELEMENT_CONTENT, error.code)
+    assert_equal(XML::Error::ERROR, error.level)
+    assert(error.file.match(/shiporder.xml/))
+    assert_nil(error.line)
+    assert_nil(error.str1)
+    assert_nil(error.str2)
+    assert_nil(error.str3)
+    assert_equal(0, error.int1)
+    assert_equal(0, error.int2)
+    assert_not_nil(error.node)
+    assert_equal('invalid', error.node.name)
+  end
+end

data/test/tc_traversal.rb

@@ -0,0 +1,222 @@
+# encoding: UTF-8
+
+require './test_helper'
+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

data/test/tc_xinclude.rb

@@ -0,0 +1,21 @@
+# encoding: UTF-8
+
+require './test_helper'
+require 'test/unit'
+
+class TestXInclude < Test::Unit::TestCase
+  def setup
+    @doc = XML::Document.file(File.join(File.dirname(__FILE__), 'model/xinclude.xml'))
+    assert_instance_of(XML::Document, @doc)
+  end
+
+  def teardown
+    @doc = nil
+  end
+
+  def test_ruby_xml_xinclude
+    assert_equal(1, @doc.xinclude)
+    assert_equal("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<document xmlns:xi=\"http://www.w3.org/2001/XInclude\">\n  <p>This libxml2 binding has the following project information:\n   <code>This is some text to include in an xml file via XInclude.</code></p>\n</document>\n",
+                 @doc.to_s)
+  end
+end

data/test/tc_xml.rb

@@ -0,0 +1,226 @@
+# encoding: UTF-8
+
+require './test_helper'
+require 'test/unit'
+require 'stringio'
+
+class TestXml < Test::Unit::TestCase
+  # -----  Constants  ------
+  def test_lib_versions
+    assert(XML.check_lib_versions)
+  end
+
+  def test_debug_entities
+    XML.debug_entities = false
+    assert(!XML.debug_entities)
+
+    XML.debug_entities = true
+    assert(XML.debug_entities)
+
+    XML.debug_entities = false
+    assert(!XML.debug_entities)
+  end
+
+  def test_default_compression
+    return unless XML.default_compression
+
+    0.upto(9) do |i|
+      XML.default_compression = i
+      assert_equal(i, XML.default_compression)
+    end
+
+    9.downto(0) do |i|
+      assert_equal(i, XML.default_compression = i)
+      assert_equal(i, XML.default_compression)
+    end
+
+    0.downto(-10) do |i|
+      assert_equal(i, XML.default_compression = i)
+      assert_equal(0, XML.default_compression)
+    end
+
+    10.upto(20) do |i|
+      assert_equal(i, XML.default_compression = i)
+      assert_equal(9, XML.default_compression)
+    end
+  end
+
+  def test_default_keep_blanks
+    XML.default_keep_blanks = false
+    assert(!XML.default_keep_blanks)
+    assert_equal(XML::Parser::Options::NOBLANKS, XML.default_options)
+
+    XML.default_keep_blanks = true
+    assert(XML.default_keep_blanks)
+    assert_equal(0, XML.default_options)
+
+    XML.default_keep_blanks = false
+    assert(!XML.default_keep_blanks)
+
+    # other tests depend on keeping blanks by default,
+    # which is the default default behaviour anyway.
+    XML.default_keep_blanks = true
+  end
+
+  def test_default_line_numbers
+    XML.default_line_numbers = false
+    assert(!XML.default_line_numbers)
+
+    XML.default_line_numbers = true
+    assert(XML.default_line_numbers)
+
+    XML.default_line_numbers = false
+    assert(!XML.default_line_numbers)
+  end
+
+  def test_default_substitute_entities
+    XML.default_substitute_entities = false
+    assert(!XML.default_substitute_entities)
+    assert_equal(0, XML.default_options)
+
+    XML.default_substitute_entities = true
+    assert(XML.default_substitute_entities)
+    assert_equal(XML::Parser::Options::NOENT, XML.default_options)
+
+    XML.default_substitute_entities = false
+    assert(!XML.default_substitute_entities)
+  end
+
+  def test_default_tree_indent_string
+    s = XML.default_tree_indent_string
+    assert_instance_of(String, s)
+    assert_equal('  ', s)
+    XML.default_tree_indent_string = 'uga'
+    s = XML.default_tree_indent_string
+    assert_instance_of(String, s)
+    assert_equal('uga', s)
+    XML.default_tree_indent_string = '  '
+    s = XML.default_tree_indent_string
+    assert_instance_of(String, s)
+    assert_equal('  ', s)
+  end
+
+  def test_default_validity_checking
+    XML.default_validity_checking = false
+    assert(!XML.default_validity_checking)
+    assert_equal(0, XML.default_options)
+
+    XML.default_validity_checking = true
+    assert(XML.default_validity_checking)
+    assert_equal(XML::Parser::Options::DTDVALID, XML.default_options)
+
+    XML.default_validity_checking = false
+    assert(!XML.default_validity_checking)
+  end
+
+  def test_default_warnings
+    XML.default_warnings = false
+    assert(!XML.default_warnings)
+    assert_equal(XML::Parser::Options::NOWARNING, XML.default_options)
+
+    XML.default_warnings = true
+    assert(XML.default_warnings)
+    assert_equal(0, XML.default_options)
+
+    XML.default_warnings = false
+    assert(!XML.default_warnings)
+  end
+
+  def test_enabled_automata
+    assert_equal(true, XML.enabled_automata?)
+  end
+
+  def test_enabled_c14n
+    assert_equal(true, XML.enabled_c14n?)
+  end
+
+  def test_enabled_catalog
+    assert_equal(true, XML.enabled_catalog?)
+  end
+
+  def test_enabled_debug
+    assert_equal(true, XML.enabled_debug?)
+  end
+
+  def test_enabled_docbook
+    assert_equal(true, XML.enabled_docbook?)
+  end
+
+  def test_enabled_ftp
+    assert_equal(true, XML.enabled_ftp?)
+  end
+
+  def test_enabled_http
+    assert_equal(true, XML.enabled_http?)
+  end
+
+  def test_enabled_html
+    assert_equal(true, XML.enabled_html?)
+  end
+
+  def test_enabled_iconv
+    assert_equal(true, XML.enabled_iconv?)
+  end
+
+  def test_enabled_memory_debug
+    assert_equal(false, XML.enabled_memory_debug?)
+  end
+
+  def test_enabled_regexp
+    assert_equal(true, XML.enabled_regexp?)
+  end
+
+  def test_enabled_schemas
+    assert_equal(true, XML.enabled_schemas?)
+  end
+
+  def test_enabled_thread
+    assert_equal(true, XML.enabled_thread?)
+  end
+
+  def test_enabled_unicode
+    assert_equal(true, XML.enabled_unicode?)
+  end
+
+  def test_enabled_xinclude
+    assert_equal(true, XML.enabled_xinclude?)
+  end
+
+  def test_enabled_xpath
+    assert_equal(true, XML.enabled_xpath?)
+  end
+
+  def test_enabled_xpointer
+    assert_equal(true, XML.enabled_xpointer?)
+  end
+
+  def test_enabled_zlib
+    assert_equal(true, XML.enabled_zlib?)
+  end
+
+  def test_intent_tree_output
+    assert(TrueClass, XML.indent_tree_output)
+
+    XML.indent_tree_output = false
+    assert(FalseClass, XML.indent_tree_output)
+
+    XML.indent_tree_output = true
+    assert(TrueClass, XML.indent_tree_output)
+  end
+
+  def test_version
+    assert_instance_of(String, XML::VERSION)
+  end
+
+  def test_vernum
+    assert_instance_of(Fixnum, XML::VERNUM)
+  end
+
+  def test_libxml_parser_features
+    assert_instance_of(Array, XML.features)
+  end
+
+  def test_default_options
+    assert_equal(0, XML.default_options)
+  end
+end