libxml-ruby 2.8.0 → 3.2.3

data/test/tc_document_write.rb

@@ -1,196 +0,0 @@
-# encoding: UTF-8
-
-require './test_helper'
-require 'tmpdir'
-require 'test/unit'
-
-class TestDocumentWrite < Test::Unit::TestCase
-  def setup
-    @file_name = "model/bands.utf-8.xml"
-
-    # Strip spaces to make testing easier
-    XML.default_keep_blanks = false
-    file = File.join(File.dirname(__FILE__), @file_name)
-    @doc = XML::Document.file(file)
-  end
-
-  def teardown
-    XML.default_keep_blanks = true
-    @doc = nil
-  end
-
-  # ---  to_s tests  ---
-  def test_to_s_default
-    # Default to_s has indentation
-    if defined?(Encoding)
-      assert_equal("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<bands genre=\"metal\">\n  <m\u00F6tley_cr\u00FCe country=\"us\">M\u00F6tley Cr\u00FCe is an American heavy metal band formed in Los Angeles, California in 1981.</m\u00F6tley_cr\u00FCe>\n  <iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>\n",
-                   @doc.to_s)
-    else
-      assert_equal("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<bands genre=\"metal\">\n  <m\303\266tley_cr\303\274e country=\"us\">M\303\266tley Cr\303\274e is an American heavy metal band formed in Los Angeles, California in 1981.</m\303\266tley_cr\303\274e>\n  <iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>\n",
-                   @doc.to_s)
-    end
-  end
-
-  def test_to_s_no_global_indentation
-    # No indentation due to global setting
-    XML.indent_tree_output = false
-    value = @doc.to_s
-
-    if defined?(Encoding)
-      assert_equal(Encoding::UTF_8, value.encoding)
-      assert_equal("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<bands genre=\"metal\">\n<m\u00F6tley_cr\u00FCe country=\"us\">M\u00F6tley Cr\u00FCe is an American heavy metal band formed in Los Angeles, California in 1981.</m\u00F6tley_cr\u00FCe>\n<iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>\n",
-                   value)
-    else
-      assert_equal("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<bands genre=\"metal\">\n<m\303\266tley_cr\303\274e country=\"us\">M\303\266tley Cr\303\274e is an American heavy metal band formed in Los Angeles, California in 1981.</m\303\266tley_cr\303\274e>\n<iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>\n",
-                   value)
-    end
-  ensure
-    XML.indent_tree_output = true
-  end
-
-  def test_to_s_no_indentation
-    # No indentation due to local setting
-    value = @doc.to_s(:indent => false)
-    if defined?(Encoding)
-      assert_equal(Encoding::UTF_8, value.encoding)
-      assert_equal("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<bands genre=\"metal\"><m\u00F6tley_cr\u00FCe country=\"us\">M\u00F6tley Cr\u00FCe is an American heavy metal band formed in Los Angeles, California in 1981.</m\u00F6tley_cr\u00FCe><iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden></bands>\n",
-                   value)
-    else
-      assert_equal("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<bands genre=\"metal\"><m\303\266tley_cr\303\274e country=\"us\">M\303\266tley Cr\303\274e is an American heavy metal band formed in Los Angeles, California in 1981.</m\303\266tley_cr\303\274e><iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden></bands>\n",
-                   value)
-    end
-  end
-
-  def test_to_s_encoding
-    # Test encodings
-
-    # UTF8:
-    # ö - c3 b6 in hex, \303\266 in octal
-    # ü - c3 bc in hex, \303\274 in octal
-    value = @doc.to_s(:encoding => XML::Encoding::UTF_8)
-    if defined?(Encoding)
-      assert_equal(Encoding::UTF_8, value.encoding)
-      assert_equal("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<bands genre=\"metal\">\n  <m\u00F6tley_cr\u00FCe country=\"us\">M\u00F6tley Cr\u00FCe is an American heavy metal band formed in Los Angeles, California in 1981.</m\u00F6tley_cr\u00FCe>\n  <iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>\n",
-                   value)
-    else
-      assert_equal("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<bands genre=\"metal\">\n  <m\303\266tley_cr\303\274e country=\"us\">M\303\266tley Cr\303\274e is an American heavy metal band formed in Los Angeles, California in 1981.</m\303\266tley_cr\303\274e>\n  <iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>\n",
-                   value)
-    end
-
-    # ISO_8859_1:
-    # ö - f6 in hex, \366 in octal
-    # ü - fc in hex, \374 in octal
-    value = @doc.to_s(:encoding => XML::Encoding::ISO_8859_1)
-    if defined?(Encoding)
-      assert_equal(Encoding::ISO8859_1, value.encoding)
-      assert_equal("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n<bands genre=\"metal\">\n  <m\xF6tley_cr\xFCe country=\"us\">M\xF6tley Cr\xFCe is an American heavy metal band formed in Los Angeles, California in 1981.</m\xF6tley_cr\xFCe>\n  <iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>\n".force_encoding(Encoding::ISO8859_1),
-                   @doc.to_s(:encoding => XML::Encoding::ISO_8859_1))
-    else
-      assert_equal("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n<bands genre=\"metal\">\n  <m\366tley_cr\374e country=\"us\">M\366tley Cr\374e is an American heavy metal band formed in Los Angeles, California in 1981.</m\366tley_cr\374e>\n  <iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>\n",
-                   @doc.to_s(:encoding => XML::Encoding::ISO_8859_1))
-    end
-
-    # Invalid encoding
-    error = assert_raise(ArgumentError) do
-      @doc.to_s(:encoding => -9999)
-    end
-    assert_equal('Unknown encoding value: -9999', error.to_s)
-  end
-
-  # --- save tests -----
-  def test_save_utf8
-    temp_filename = File.join(Dir.tmpdir, "tc_document_write_test_save_utf8.xml")
-
-    bytes = @doc.save(temp_filename)
-    assert_equal(305, bytes)
-
-    if defined?(Encoding)
-      contents = File.read(temp_filename, nil, nil, :encoding => Encoding::UTF_8)
-      assert_equal(Encoding::UTF_8, contents.encoding)
-      assert_equal("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<bands genre=\"metal\">\n  <m\u00F6tley_cr\u00FCe country=\"us\">M\u00F6tley Cr\u00FCe is an American heavy metal band formed in Los Angeles, California in 1981.</m\u00F6tley_cr\u00FCe>\n  <iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>\n",
-                    contents)
-    else
-      contents = File.read(temp_filename)
-      assert_equal("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<bands genre=\"metal\">\n  <m\303\266tley_cr\303\274e country=\"us\">M\303\266tley Cr\303\274e is an American heavy metal band formed in Los Angeles, California in 1981.</m\303\266tley_cr\303\274e>\n  <iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>\n",
-                 contents)
-    end
-  ensure
-    File.delete(temp_filename)
-  end
-
-  def test_save_utf8_no_indents
-    temp_filename = File.join(Dir.tmpdir, "tc_document_write_test_save_utf8_no_indents.xml")
-
-    bytes = @doc.save(temp_filename, :indent => false)
-    assert_equal(298, bytes)
-
-    if defined?(Encoding)
-      contents = File.read(temp_filename, nil, nil, :encoding => Encoding::UTF_8)
-      assert_equal("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<bands genre=\"metal\"><m\u00F6tley_cr\u00FCe country=\"us\">M\u00F6tley Cr\u00FCe is an American heavy metal band formed in Los Angeles, California in 1981.</m\u00F6tley_cr\u00FCe><iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden></bands>\n",
-                 contents)
-    else
-      contents = File.read(temp_filename)
-      assert_equal("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<bands genre=\"metal\"><m\303\266tley_cr\303\274e country=\"us\">M\303\266tley Cr\303\274e is an American heavy metal band formed in Los Angeles, California in 1981.</m\303\266tley_cr\303\274e><iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden></bands>\n",
-                 contents)
-    end
-  ensure
-    File.delete(temp_filename)
-  end
-
-  def test_save_iso_8859_1
-    temp_filename = File.join(Dir.tmpdir, "tc_document_write_test_save_iso_8859_1.xml")
-    bytes = @doc.save(temp_filename, :encoding => XML::Encoding::ISO_8859_1)
-    assert_equal(304, bytes)
-
-    if defined?(Encoding)
-      contents = File.read(temp_filename, nil, nil, :encoding => Encoding::ISO8859_1)
-      assert_equal(Encoding::ISO8859_1, contents.encoding)
-      assert_equal("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n<bands genre=\"metal\">\n  <m\xF6tley_cr\xFCe country=\"us\">M\xF6tley Cr\xFCe is an American heavy metal band formed in Los Angeles, California in 1981.</m\xF6tley_cr\xFCe>\n  <iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>\n".force_encoding(Encoding::ISO8859_1),
-                 contents)
-    else
-      contents = File.read(temp_filename)
-      assert_equal("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n<bands genre=\"metal\">\n  <m\xF6tley_cr\xFCe country=\"us\">M\xF6tley Cr\xFCe is an American heavy metal band formed in Los Angeles, California in 1981.</m\xF6tley_cr\xFCe>\n  <iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden>\n</bands>\n",
-                 contents)
-    end
-  ensure
-    File.delete(temp_filename)
-  end
-
-  def test_save_iso_8859_1_no_indent
-    temp_filename = File.join(Dir.tmpdir, "tc_document_write_test_save_iso_8859_1_no_indent.xml")
-    bytes = @doc.save(temp_filename, :indent => false, :encoding => XML::Encoding::ISO_8859_1)
-    assert_equal(297, bytes)
-
-    if defined?(Encoding)
-      contents = File.read(temp_filename, nil, nil, :encoding => Encoding::ISO8859_1)
-      assert_equal(Encoding::ISO8859_1, contents.encoding)
-      assert_equal("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n<bands genre=\"metal\"><m\xF6tley_cr\xFCe country=\"us\">M\xF6tley Cr\xFCe is an American heavy metal band formed in Los Angeles, California in 1981.</m\xF6tley_cr\xFCe><iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden></bands>\n".force_encoding(Encoding::ISO8859_1),
-                   contents)
-    else
-      contents = File.read(temp_filename)
-      assert_equal("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n<bands genre=\"metal\"><m\xF6tley_cr\xFCe country=\"us\">M\xF6tley Cr\xFCe is an American heavy metal band formed in Los Angeles, California in 1981.</m\xF6tley_cr\xFCe><iron_maiden country=\"uk\">Iron Maiden is a British heavy metal band formed in 1975.</iron_maiden></bands>\n",
-                   contents)
-    end
-  ensure
-    File.delete(temp_filename)
-  end
-
-  def test_thread_set_root
-    # Previously a segmentation fault occurred when running libxml in
-    # background threads.
-    thread = Thread.new do
-      100000.times do |i|
-        document = LibXML::XML::Document.new
-        node = LibXML::XML::Node.new('test')
-        document.root = node
-      end
-    end
-    thread.join
-    assert(true)
-  end
-
-  # --- Debug ---
-  def test_debug
-    assert(@doc.debug)
-  end
-end

data/test/tc_error.rb

@@ -1,180 +0,0 @@
-# encoding: UTF-8
-
-require './test_helper'
-require 'test/unit'
-require 'stringio'
-
-class TestError < Test::Unit::TestCase
-  def test_error_codes
-    assert_equal(4, XML::Error::DTD)
-    assert_equal(4, XML::Error.const_get('DTD'))
-
-    assert_equal(4, XML::Error::DOCUMENT_EMPTY)
-    assert_equal(4, XML::Error.const_get('DOCUMENT_EMPTY'))
-  end
-
-  def test_invalid_handler
-    assert_raise(RuntimeError) do
-      XML::Error.set_handler
-    end
-  end
-
-  def test_handler
-    exception = nil
-    XML::Error.set_handler do |error|
-      exception = error
-    end
-
-    # Raise the error
-    error = assert_raise(XML::Error) do
-      XML::Reader.string('<foo').read
-    end
-    assert_equal(exception, error)
-
-    # Check the handler worked
-    assert_not_nil(exception)
-    assert_kind_of(XML::Error, exception)
-    assert_equal("Fatal error: Couldn't find end of Start Tag foo at :1.", exception.message)
-    assert_equal(XML::Error::PARSER, exception.domain)
-    assert_equal(XML::Error::GT_REQUIRED, exception.code)
-    assert_equal(XML::Error::FATAL, exception.level)
-    assert_nil(exception.file)
-    assert_equal(1, exception.line)
-    assert_equal('foo', exception.str1)
-    assert_nil(exception.str2)
-    assert_nil(exception.str3)
-    assert_equal(0, exception.int1)
-    assert_equal(5, exception.int2)
-    assert_nil(exception.node)
-  end
-
-  def test_reset_handler
-    exception = nil
-    XML::Error.set_handler do |error|
-      exception = error
-    end
-
-    XML::Error.reset_handler
-    XML::Reader.string('<foo')
-    assert_nil(exception)
-  end
-
-  def test_get_handler
-    assert_respond_to(XML::Error, :get_handler)
-    assert_equal(0, XML::Error.method(:get_handler).arity)
-
-    saved_handler = XML::Error.get_handler
-    XML::Error.set_handler{ puts "New handler" }
-    assert_not_equal(XML::Error.get_handler, saved_handler)
-
-    XML::Error.set_handler(&saved_handler)
-    assert_equal(XML::Error.get_handler, saved_handler)
-  end
-
-  def test_verbose_handler
-    XML::Error.set_handler(&XML::Error::VERBOSE_HANDLER)
-    output = StringIO.new
-    original_stderr = Object::STDERR
-
-    Object.const_set(:STDERR, output)
-    begin
-      assert_raise(XML::Error) do
-        XML::Parser.string('<foo><bar/></foz>').parse
-      end
-    ensure
-      Object.const_set(:STDERR, original_stderr)
-    end
-    assert_equal("Fatal error: Opening and ending tag mismatch: foo line 1 and foz at :1.\n", output.string)
-  end
-
-  def test_no_hanlder
-    XML::Error.reset_handler
-    output = StringIO.new
-    original_stderr = Object::STDERR
-
-    Object.const_set(:STDERR, output)
-    begin
-      assert_raise(XML::Error) do
-        XML::Parser.string('<foo><bar/></foz>').parse
-      end
-    ensure
-      Object.const_set(:STDERR, original_stderr)
-    end
-    assert_equal('', output.string)
-  end
-
-  def test_parse_error
-    exception = assert_raise(XML::Error) do
-      XML::Parser.string('<foo><bar/></foz>').parse
-    end
-
-    assert_instance_of(XML::Error, exception)
-    assert_equal("Fatal error: Opening and ending tag mismatch: foo line 1 and foz at :1.", exception.message)
-    assert_equal(XML::Error::PARSER, exception.domain)
-    assert_equal(XML::Error::TAG_NAME_MISMATCH, exception.code)
-    assert_equal(XML::Error::FATAL, exception.level)
-    assert_nil(exception.file)
-    assert_equal(1, exception.line)
-  end
-
-  def test_xpath_error
-    doc = XML::Document.file(File.join(File.dirname(__FILE__), 'model/soap.xml'))
-
-    exception = assert_raise(XML::Error) do
-      doc.find('/foo[bar=test')
-    end
-
-    assert_instance_of(XML::Error, exception)
-    assert_equal("Error: Invalid predicate.", exception.message)
-    assert_equal(XML::Error::XPATH, exception.domain)
-    assert_equal(XML::Error::XPATH_INVALID_PREDICATE_ERROR, exception.code)
-    assert_equal(XML::Error::ERROR, exception.level)
-    assert_nil(exception.file)
-    assert_nil(nil)
-  end
-
-  def test_double_parse
-    XML::Parser.register_error_handler(lambda {|msg| nil })
-    parser = XML::Parser.string("<test>something</test>")
-    parser.parse
-
-    error = assert_raise(XML::Error) do
-      # Try parsing a second time
-      parser.parse
-    end
-
-    assert_equal(" LibXML::XML::Error.", error.to_s)
-  end
-
-  def test_libxml_parser_empty_string
-    xp = XML::Parser.new
-
-    error = assert_raise(TypeError) do
-      xp.string = nil
-    end
-    assert_equal('wrong argument type nil (expected String)', error.to_s)
-
-    error = assert_raise(ArgumentError) do
-      xp.string = ''
-    end
-    assert_equal('Must specify a string with one or more characters', error.to_s)
-  end
-
-  def test_error_domain_to_s
-    exception = assert_raise(XML::Error) do
-      XML::Parser.string('<foo href="http://example.org/cgi?k1=v1&k2=v2"></foo>').parse
-    end
-
-    assert_equal(XML::Error::PARSER, exception.domain)
-    assert_equal("PARSER",exception.domain_to_s)
-  end
-
-  def test_error_code_to_s
-    exception = assert_raise(XML::Error) do
-      XML::Parser.string('<foo href="http://example.org/cgi?k1=v1&k2=v2"></foo>').parse
-    end
-    assert_equal(XML::Error::ENTITYREF_SEMICOL_MISSING, exception.code)
-    assert_equal("ENTITYREF_SEMICOL_MISSING",exception.code_to_s)
-  end
-
-end

data/test/tc_html_parser.rb

@@ -1,153 +0,0 @@
-# encoding: UTF-8
-
-require './test_helper'
-require 'stringio'
-require 'test/unit'
-
-class HTMLParserTest < Test::Unit::TestCase
-  def html_file
-    File.expand_path(File.join(File.dirname(__FILE__), 'model/ruby-lang.html'))
-  end
-
-  # -----  Sources  ------
-  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_noexistent_file
-    error = assert_raise(XML::Error) do
-      XML::HTMLParser.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::HTMLParser.file(nil)
-    end
-
-    assert_match(/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)
-    xp = XML::HTMLParser.io(io)
-    assert_instance_of(XML::HTMLParser, xp)
-
-    doc = xp.parse
-    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>
-        <head>
-          <meta name=keywords content=nasty>
-        </head>
-        <body>Hello<br>World</html>
-   EOS
-
-    parser = XML::HTMLParser.string(html, :options => XML::HTMLParser::Options::NOBLANKS)
-    doc = parser.parse
-    assert_instance_of XML::Document, doc
-
-    root = doc.root
-    assert_instance_of XML::Node, root
-    assert_equal 'html', root.name
-
-    head = root.child
-    assert_instance_of XML::Node, head
-    assert_equal 'head', head.name
-
-    meta = head.child
-    assert_instance_of XML::Node, meta
-    assert_equal 'meta', meta.name
-    assert_equal 'keywords', meta[:name]
-    assert_equal 'nasty', meta[:content]
-
-    body = head.next
-    assert_instance_of XML::Node, body
-    assert_equal 'body', body.name
-
-    hello = body.child
-    # It appears that some versions of libxml2 add a layer of <p>
-    # cant figure our why or how, so this skips it if there
-    hello = hello.child if hello.name == "p"
-
-    assert_instance_of XML::Node, hello
-    assert_equal 'Hello', hello.content
-
-    br = hello.next
-    assert_instance_of XML::Node, br
-    assert_equal 'br', br.name
-
-    world = br.next
-    assert_instance_of XML::Node, world
-    assert_equal 'World', world.content
-  end
-
-  def test_no_implied
-    html = "hello world"
-    parser = XML::HTMLParser.string(html, :options => XML::HTMLParser::Options::NOIMPLIED)
-    doc = parser.parse
-    assert_equal("<p>#{html}</p>", doc.root.to_s)
-  end
-
-  def test_open_many_files
-    1000.times do
-      doc = XML::HTMLParser.file('model/ruby-lang.html').parse
-    end
-  end
-end

data/test/tc_html_parser_context.rb

@@ -1,24 +0,0 @@
-# encoding: UTF-8
-
-require './test_helper'
-
-require 'test/unit'
-
-class TestHtmlParserContext < Test::Unit::TestCase
-  def test_default_options
-    context = XML::HTMLParser::Context.new
-    assert_equal(0, context.options)
-  end
-
-  def test_no_options
-    context = XML::HTMLParser::Context.new
-    context.options = 0
-    assert_equal(0, context.options)
-  end
-
-  def test_options
-    context = XML::HTMLParser::Context.new
-    context.options = XML::HTMLParser::Options::NOERROR
-    assert_equal(XML::HTMLParser::Options::NOERROR, context.options)
-  end
-end

data/test/tc_namespace.rb

@@ -1,62 +0,0 @@
-# encoding: UTF-8
-
-require './test_helper'
-
-require 'test/unit'
-
-class TestNS < Test::Unit::TestCase
-  def setup
-    file = File.join(File.dirname(__FILE__), 'model/soap.xml')
-    @doc = XML::Document.file(file)
-  end
-
-  def teardown
-    @doc = nil
-  end
-
-  def test_create_ns
-    node = XML::Node.new('foo')
-    ns = XML::Namespace.new(node, 'my_namepace', 'http://www.mynamespace.com')
-    assert_equal(ns.prefix, 'my_namepace')
-    assert_equal(ns.href, 'http://www.mynamespace.com')
-  end
-
-  def test_create_default_ns
-    node = XML::Node.new('foo')
-    ns = XML::Namespace.new(node, nil, 'http://www.mynamespace.com')
-    assert_equal(ns.prefix, nil)
-    assert_equal(ns.href, 'http://www.mynamespace.com')
-  end
-
-  def test_create_unbound_ns
-    error = assert_raise(TypeError) do
-      XML::Namespace.new(nil, 'my_namepace', 'http://www.mynamespace.com')
-    end
-    assert_equal('wrong argument type nil (expected Data)', error.to_s)
-  end
-
-  def test_duplicate_ns
-    node = XML::Node.new('foo')
-    XML::Namespace.new(node, 'myname', 'http://www.mynamespace.com')
-    assert_raises(XML::Error) do
-      XML::Namespace.new(node, 'myname', 'http://www.mynamespace.com')
-    end
-  end
-
-  def test_eql
-    node = XML::Node.new('Envelope')
-    ns = XML::Namespace.new(node, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
-
-    assert(node.namespaces.namespace.eql?(node.namespaces.namespace))
-  end
-
-  def test_equal
-    node1 = XML::Node.new('Envelope')
-    ns1 = XML::Namespace.new(node1, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
-
-    node2 = XML::Node.new('Envelope')
-    ns2 = XML::Namespace.new(node2, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
-
-    assert(ns1 == ns2)
-  end
-end

data/test/tc_node_xlink.rb

@@ -1,29 +0,0 @@
-# encoding: UTF-8
-
-# $Id$
-require './test_helper'
-
-require 'test/unit'
-
-class TC_XML_Node_XLink < Test::Unit::TestCase
-  def setup()
-    xp = XML::Parser.string('<ruby_array xmlns:xlink="http://www.w3.org/1999/xlink/namespace/"><fixnum xlink:type="simple">one</fixnum></ruby_array>')
-    doc = xp.parse
-    assert_instance_of(XML::Document, doc)
-    @root = doc.root
-    assert_instance_of(XML::Node, @root)
-  end
-
-  def teardown()
-    @root = nil
-  end
-
-  def test_xml_node_xlink()
-    for elem in @root.find('fixnum')
-      assert_instance_of(XML::Node, elem)
-      assert_instance_of(TrueClass, elem.xlink?)
-      assert_equal("simple", elem.xlink_type_name)
-      assert_equal(XML::Node::XLINK_TYPE_SIMPLE, elem.xlink_type)
-    end
-  end
-end