libxml-ruby 0.6.0-x86-mswin32-60

data/test/tc_xml_parser2.rb

@@ -0,0 +1,16 @@
+require "libxml"
+require 'test/unit'
+
+class TC_XML_Parser2 < Test::Unit::TestCase
+  def setup()
+    @xp = XML::Parser.new()
+  end
+
+  def teardown()
+    @xp = nil
+  end
+
+  def test_ruby_xml_parser_new()
+    assert_instance_of(XML::Parser, @xp)
+  end
+end # TC_XML_Document

data/test/tc_xml_parser3.rb

@@ -0,0 +1,23 @@
+# $Id: tc_xml_parser3.rb 251 2008-01-22 18:12:00Z transami $
+require "libxml"
+require 'test/unit'
+
+class TC_XML_Parser3 < Test::Unit::TestCase
+  def setup()
+    @xp = XML::Parser.new()
+    assert_instance_of(XML::Parser, @xp)
+    s = @xp.string = '<u>a</u>'
+    assert_instance_of(String, s)
+    assert_instance_of(String, @xp.string)
+    assert_equal(s, @xp.string)
+  end
+
+  def teardown()
+    @xp = nil
+  end
+
+  def test_ruby_xml_parser_new()
+    assert_instance_of(XML::Parser, @xp)
+    assert_instance_of(String, @xp.string)
+  end
+end

data/test/tc_xml_parser4.rb

@@ -0,0 +1,33 @@
+# $Id: tc_xml_parser4.rb 251 2008-01-22 18:12:00Z transami $
+require "libxml"
+require 'test/unit'
+
+class TC_XML_Parser4 < Test::Unit::TestCase
+  def setup()
+    @xp1 = XML::Parser.new()
+    assert_instance_of(XML::Parser, @xp1)
+    s1 = @xp1.string = '<u>a</u>'
+    assert_instance_of(String, s1)
+    assert_instance_of(String, @xp1.string)
+    assert_equal(s1, @xp1.string)
+
+    @xp2 = XML::Parser.string('<u>a</u>')
+    assert_instance_of(XML::Parser, @xp2)
+    assert_instance_of(String, @xp2.string)
+    assert_equal(s1, @xp2.string)
+    assert_equal(@xp1.string, @xp2.string)
+  end
+
+  def teardown()
+    @xp1 = nil
+    @xp2 = nil
+  end
+
+  def test_ruby_xml_parser_new()
+    assert_instance_of(XML::Parser, @xp1)
+    assert_instance_of(String, @xp1.string)
+    assert_instance_of(XML::Parser, @xp2)
+    assert_instance_of(String, @xp2.string)
+    assert_equal(@xp1.string, @xp2.string)
+  end
+end # TC_XML_Document

data/test/tc_xml_parser5.rb

@@ -0,0 +1,27 @@
+# $Id: tc_xml_parser5.rb 251 2008-01-22 18:12:00Z transami $
+require "libxml"
+require 'test/unit'
+
+class TC_XML_Parser5 < Test::Unit::TestCase
+  def setup()
+    @xp = XML::Parser.new()
+    assert_instance_of(XML::Parser, @xp)
+    s = @xp.string = '<u>a</u>'
+    assert_instance_of(String, s)
+    assert_instance_of(String, @xp.string)
+    assert_equal(s, @xp.string)
+    @doc = @xp.parse
+    assert_instance_of(XML::Document, @doc)
+  end
+
+  def teardown()
+    @xp = nil
+    @doc = nil
+  end
+
+  def test_ruby_xml_parser_new()
+    assert_instance_of(XML::Parser, @xp)
+    assert_instance_of(String, @xp.string)
+    assert_instance_of(XML::Document, @doc)
+  end
+end

data/test/tc_xml_parser6.rb

@@ -0,0 +1,23 @@
+# $Id: tc_xml_parser6.rb 283 2008-07-01 06:48:35Z cfis $
+require "libxml"
+require 'test/unit'
+
+class TC_XML_Parser6 < Test::Unit::TestCase
+  def setup()
+    @xp = XML::Parser.new()
+    assert_instance_of(XML::Parser, @xp)
+    f = File.open('model/rubynet.xml')
+    f1 = @xp.io = f
+    assert_instance_of(File, f1)
+    assert_instance_of(File, @xp.io)
+  end
+
+  def teardown()
+    @xp = nil
+  end
+
+  def test_ruby_xml_parser_new()
+    assert_instance_of(XML::Parser, @xp)
+    assert_instance_of(File, @xp.io)
+  end
+end

data/test/tc_xml_parser7.rb

@@ -0,0 +1,28 @@
+# $Id: tc_xml_parser7.rb 283 2008-07-01 06:48:35Z cfis $
+require "libxml"
+require 'test/unit'
+
+class TC_XML_Parser7 < Test::Unit::TestCase
+  def setup()
+    @xp = XML::Parser.new()
+    assert_instance_of(XML::Parser, @xp)
+    f = File.open('model/rubynet.xml')
+    f1 = @xp.io = f
+    assert_instance_of(File, f1)
+    assert_instance_of(File, @xp.io)
+    @doc = @xp.parse
+    assert_instance_of(XML::Document, @doc)
+  end
+
+  def teardown()
+    @xp = nil
+    @doc = nil
+  end
+
+  def test_ruby_xml_parser_new()
+    assert_instance_of(XML::Parser, @xp)
+    assert_instance_of(File, @xp.io)
+    assert_instance_of(XML::Document, @doc)
+    assert_instance_of(String, @doc.version)
+  end
+end

data/test/tc_xml_parser8.rb

@@ -0,0 +1,32 @@
+# $Id: tc_xml_parser8.rb 251 2008-01-22 18:12:00Z transami $
+require "libxml"
+require 'test/unit'
+
+class TC_XML_Parser8 < Test::Unit::TestCase
+  def test_ruby_xml_parser_error_handler
+    $stderr.puts "\nEXPECTING: TWO ERRORS:"
+    # this will send message to stderr
+    assert_raise(XML::Parser::ParseError) {
+      d = XML::Parser.string('<foo><bar/></foz>').parse
+    }
+
+    ary = []
+    assert_nil XML::Parser.register_error_handler(lambda { |msg| ary << msg })
+
+    # this will use our error handler
+    assert_raise(XML::Parser::ParseError) {
+      d = XML::Parser.string('<foo><bar/></foz>').parse
+    }
+
+    assert (first_len = ary.length) > 0
+
+    assert_instance_of Proc, XML::Parser.register_error_handler(nil)
+
+    # this will go to stderr again
+    assert_raise(XML::Parser::ParseError) {
+      d = XML::Parser.string('<foo><bar/></foz>').parse
+    }
+
+    assert_equal first_len, ary.length
+  end
+end

data/test/tc_xml_parser9.rb

@@ -0,0 +1,11 @@
+require "libxml"
+require 'test/unit'
+
+class TC_XML_Parser9 < Test::Unit::TestCase
+  def test_double_parse
+    parser = XML::Parser.string("<test>something</test>")
+    doc = parser.parse
+    parser.parse
+  end
+end
+

data/test/tc_xml_parser_context.rb

@@ -0,0 +1,88 @@
+require "libxml"
+require 'test/unit'
+
+class TC_XML_Parser_Context < Test::Unit::TestCase
+  def setup()
+    str = '<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
+    xp = XML::Parser.string(str)
+    assert_equal(str, xp.string = str)
+    doc = xp.parse
+    assert_instance_of(XML::Document, doc)
+    @ctxt = xp.parser_context()
+    assert_instance_of(XML::Parser::Context, @ctxt)
+  end
+
+  def teardown()
+    @ctxt = nil
+  end
+
+  def test_libxml_parser_context_well_formed()
+    if @ctxt.well_formed?
+      assert_instance_of(TrueClass, @ctxt.well_formed?)
+    else
+      assert_instance_of(FalseClass, @ctxt.well_formed?)
+    end
+  end
+
+  def test_ruby_xml_parser_context_version_info()
+    assert_instance_of(String, @ctxt.version)
+  end
+
+  def test_ruby_xml_parser_context_depth()
+    assert_instance_of(Fixnum, @ctxt.depth)
+  end
+
+  def test_ruby_xml_parser_context_doc()
+    assert_instance_of(XML::Document, @ctxt.doc)
+  end
+
+  def test_ruby_xml_parser_context_disable_sax()
+    assert(!@ctxt.disable_sax?)
+  end
+
+  def test_ruby_xml_parser_context_docbook()
+    assert(!@ctxt.docbook?)
+  end
+
+  def test_ruby_xml_parser_context_encoding()
+    assert(!@ctxt.encoding)
+  end
+
+  def test_ruby_xml_parser_context_html()
+    assert(!@ctxt.html?)
+  end
+
+  def test_ruby_xml_parser_context_keep_blanks()
+    if @ctxt.keep_blanks?
+      assert_instance_of(TrueClass, @ctxt.keep_blanks?)
+    else
+      assert_instance_of(FalseClass, @ctxt.keep_blanks?)
+    end
+  end
+
+  if ENV['NOTWORKING']
+    def test_ruby_xml_parser_context_num_chars()
+      assert_equal(17, @ctxt.num_chars)
+    end
+  end
+
+  def test_ruby_xml_parser_context_replace_entities()
+    if @ctxt.replace_entities?
+      assert_instance_of(TrueClass, @ctxt.replace_entities?)
+    else
+      assert_instance_of(FalseClass, @ctxt.replace_entities?)
+    end
+  end
+
+  def test_ruby_xml_parser_context_space_depth()
+    assert_equal(1, @ctxt.space_depth)
+  end
+
+  def test_ruby_xml_parser_context_subset_external()
+    assert(!@ctxt.subset_external?)
+  end
+
+  def test_ruby_xml_parser_context_data_directory_get()
+    # assert_instance_of(String, @ctxt.data_directory)
+  end
+end # TC_XML_Parser_Context

data/test/tc_xml_reader.rb

@@ -0,0 +1,112 @@
+require 'libxml'
+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)
+    do_test_simple(reader)
+    assert_raises(RuntimeError) { XML::Reader.file('/does/not/exist') }
+  end
+
+  def test_new_data
+    reader = XML::Reader.new(File.read(SIMPLE_XML))
+    do_test_simple(reader)
+  end
+
+  def test_new_walker
+    reader = XML::Reader.walker(XML::Document.file(SIMPLE_XML))
+    do_test_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 do_test_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_xml_sax_parser.rb

@@ -0,0 +1,104 @@
+require 'libxml'
+require 'test/unit'
+
+# TODO this is woefully inadequate
+
+class TC_XML_SaxParser2 < Test::Unit::TestCase
+  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
+
+  def setup()
+    @xp = XML::SaxParser.new
+  end
+
+  def teardown()
+    @xp = nil
+  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'))
+    do_test
+  end
+
+  def test_callbacks_with_file
+    @xp.callbacks = TestCaseCallbacks.new
+    @xp.filename = File.join(File.dirname(__FILE__), 'model/saxtest.xml')
+    do_test
+  end
+
+  def do_test
+    @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_doctype
+    @xp.callbacks = TestCaseCallbacks.new
+    @xp.string = <<-EOS
+      <?xml version="1.0" encoding="UTF-8"?>
+      <!DOCTYPE ONIXmessage SYSTEM "http://www.editeur.org/onix/2.1/short/onix-international.dtd">
+      <ONIXmessage release="2.1">
+      </ONIXmessage>
+    EOS
+    @xp.parse
+  end
+end # TC_XML_Sax_Parser