RubyGems - libxml-ruby - Versions diffs - 3.0.0-x64-mingw32 → 3.2.2-x64-mingw32 - Mend

libxml-ruby 3.0.0-x64-mingw32 → 3.2.2-x64-mingw32

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (87) hide show

checksums.yaml +5 -5
data/HISTORY +37 -0
data/MANIFEST +34 -34
data/README.rdoc +65 -36
data/Rakefile +21 -3
data/ext/libxml/extconf.rb +30 -26
data/ext/libxml/ruby_libxml.h +0 -8
data/ext/libxml/ruby_xml.c +40 -0
data/ext/libxml/ruby_xml_document.c +1 -5
data/ext/libxml/ruby_xml_dtd.c +6 -8
data/ext/libxml/ruby_xml_encoding.c +1 -13
data/ext/libxml/ruby_xml_encoding.h +0 -3
data/ext/libxml/ruby_xml_error.c +1 -1
data/ext/libxml/ruby_xml_error.h +1 -1
data/ext/libxml/ruby_xml_io.c +14 -18
data/ext/libxml/ruby_xml_io.h +1 -1
data/ext/libxml/ruby_xml_node.c +16 -17
data/ext/libxml/ruby_xml_parser_context.c +1 -1
data/ext/libxml/ruby_xml_reader.c +7 -2
data/ext/libxml/ruby_xml_schema.c +44 -66
data/ext/libxml/ruby_xml_schema_element.c +15 -14
data/ext/libxml/ruby_xml_schema_type.c +66 -93
data/ext/libxml/ruby_xml_version.h +4 -4
data/ext/libxml/ruby_xml_writer.c +189 -192
data/lib/3.0/libxml_ruby.so +0 -0
data/lib/libxml/schema/element.rb +0 -8
data/lib/libxml/schema/type.rb +0 -8
data/lib/libxml/schema.rb +0 -19
data/lib/libxml-ruby.rb +30 -0
data/lib/libxml.rb +3 -28
data/libxml-ruby.gemspec +5 -4
data/setup.rb +0 -1
data/test/model/cwm_1_0.xml +11336 -0
data/test/{tc_attr.rb → test_attr.rb} +18 -18
data/test/{tc_attr_decl.rb → test_attr_decl.rb} +8 -8
data/test/{tc_attributes.rb → test_attributes.rb} +10 -10
data/test/{tc_canonicalize.rb → test_canonicalize.rb} +35 -39
data/test/test_deprecated_require.rb +12 -0
data/test/{tc_document.rb → test_document.rb} +31 -24
data/test/test_document_write.rb +146 -0
data/test/{tc_dtd.rb → test_dtd.rb} +26 -25
data/test/{tc_encoding.rb → test_encoding.rb} +20 -17
data/test/{tc_encoding_sax.rb → test_encoding_sax.rb} +3 -3
data/test/test_error.rb +178 -0
data/test/test_helper.rb +4 -11
data/test/{tc_html_parser.rb → test_html_parser.rb} +31 -30
data/test/test_html_parser_context.rb +23 -0
data/test/test_namespace.rb +60 -0
data/test/{tc_namespaces.rb → test_namespaces.rb} +29 -38
data/test/{tc_node.rb → test_node.rb} +37 -31
data/test/{tc_node_cdata.rb → test_node_cdata.rb} +10 -10
data/test/{tc_node_comment.rb → test_node_comment.rb} +6 -6
data/test/{tc_node_copy.rb → test_node_copy.rb} +3 -4
data/test/{tc_node_edit.rb → test_node_edit.rb} +20 -21
data/test/{tc_node_pi.rb → test_node_pi.rb} +8 -10
data/test/{tc_node_text.rb → test_node_text.rb} +8 -9
data/test/{tc_node_write.rb → test_node_write.rb} +16 -26
data/test/test_node_xlink.rb +28 -0
data/test/{tc_parser.rb → test_parser.rb} +72 -75
data/test/{tc_parser_context.rb → test_parser_context.rb} +38 -44
data/test/{tc_properties.rb → test_properties.rb} +5 -5
data/test/test_reader.rb +364 -0
data/test/{tc_relaxng.rb → test_relaxng.rb} +11 -11
data/test/{tc_sax_parser.rb → test_sax_parser.rb} +38 -31
data/test/{tc_schema.rb → test_schema.rb} +40 -33
data/test/test_suite.rb +39 -40
data/test/{tc_traversal.rb → test_traversal.rb} +4 -4
data/test/{tc_writer.rb → test_writer.rb} +95 -74
data/test/{tc_xinclude.rb → test_xinclude.rb} +3 -3
data/test/test_xml.rb +263 -0
data/test/{tc_xpath.rb → test_xpath.rb} +25 -25
data/test/{tc_xpath_context.rb → test_xpath_context.rb} +5 -5
data/test/{tc_xpath_expression.rb → test_xpath_expression.rb} +7 -7
data/test/{tc_xpointer.rb → test_xpointer.rb} +15 -15
metadata +92 -106
data/lib/2.4/libxml_ruby.so +0 -0
data/lib/libs/libiconv-2.dll +0 -0
data/lib/libs/libxml2-2.dll +0 -0
data/lib/libs/zlib1.dll +0 -0
data/test/tc_deprecated_require.rb +0 -12
data/test/tc_document_write.rb +0 -195
data/test/tc_error.rb +0 -178
data/test/tc_html_parser_context.rb +0 -23
data/test/tc_namespace.rb +0 -61
data/test/tc_node_xlink.rb +0 -28
data/test/tc_reader.rb +0 -358
data/test/tc_xml.rb +0 -225

data/test/tc_reader.rb DELETED Viewed

@@ -1,358 +0,0 @@
-# encoding: UTF-8
-require './test_helper'
-require 'stringio'
-class TestReader < Minitest::Test
-  XML_FILE = File.join(File.dirname(__FILE__), 'model/atom.xml')
-  def verify_simple(reader)
-    node_types = []
-    # Read each node
-    26.times do
-      assert(reader.read)
-      node_types << reader.node_type
-    end
-    # 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(XML_FILE)
-    verify_simple(reader)
-  end
-  def test_invalid_file
-    assert_raises(XML::Error) do
-      XML::Reader.file('/does/not/exist')
-    end
-  end
-  def test_string
-    reader = XML::Reader.string(File.read(XML_FILE))
-    verify_simple(reader)
-  end
-  def test_io
-    File.open(XML_FILE, 'rb') do |io|
-      reader = XML::Reader.io(io)
-      verify_simple(reader)
-    end
-  end
-  def test_io_gc
-    # Test that the reader keeps a reference
-    # to the io object
-    file = File.open(XML_FILE, 'rb')
-    reader = XML::Reader.io(file)
-    file = nil
-    GC.start
-    assert(reader.read)
-  end
-  def test_string_io
-    data = File.read(XML_FILE)
-    string_io = StringIO.new(data)
-    reader = XML::Reader.io(string_io)
-    verify_simple(reader)
-  end
-  def test_error
-    reader = XML::Reader.string('<foo blah')
-    error = assert_raises(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_attr
-    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])
-    assert_equal('2', parser['y'])
-    assert_equal('2', parser[1])
-    assert_nil(parser['z'])
-    assert_nil(parser[2])
-  end
-  def test_move_attr
-      reader = XML::Reader.string('<root xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xhtml="http://www.w3.org/1999/xhtml"><link xml:id="abc" xlink:href="def" xhtml:class="ghi" bar="jkl" /></root>')
-      assert(reader.read) # <root/>
-      assert(reader.read) # <link/>
-      assert(reader.move_to_attribute_no(1))
-      assert_equal(reader.value, 'def')
-      assert(reader.move_to_attribute_ns('id', 'http://www.w3.org/XML/1998/namespace'))
-      assert_equal(reader.value, 'abc')
-      assert(reader.move_to_attribute('bar'))
-      assert_equal(reader.value, 'jkl')
-      # 1 in case of success, -1 in case of error, 0 if not found
-      assert_equal(reader.move_to_attribute_no(12), 0)
-      assert_equal(reader.move_to_attribute('baz'), 0)
-      assert_equal(reader.move_to_attribute_ns('baz', 'http://ruby/namespace'), 0)
-  end
-  def test_get_attr
-      reader = XML::Reader.string('<root xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xhtml="http://www.w3.org/1999/xhtml"><link xml:id="abc" xlink:href="def" xhtml:class="ghi" bar="jkl" /></root>')
-      assert(reader.read) # <root/>
-      assert(reader.read) # <link/>
-      assert_equal(reader.get_attribute_no(1), 'def')
-      assert_equal(reader.get_attribute_ns('id', 'http://www.w3.org/XML/1998/namespace'), 'abc')
-      assert_equal(reader.get_attribute('bar'), 'jkl')
-      assert_equal(reader.get_attribute_no(12), nil)
-      assert_equal(reader.get_attribute('baz'), nil)
-      assert_equal(reader.get_attribute_ns('baz', 'http://ruby/namespace'), nil)
-  end
-  def test_value
-    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(parser.read)
-      assert_equal(XML::Reader::TYPE_ELEMENT, parser.node_type)
-      assert_equal('bar', parser.name)
-      assert(parser.read)
-      assert_equal(XML::Reader::TYPE_TEXT, parser.node_type)
-      assert_equal((i + 1).to_s, parser.value)
-      assert(parser.read)
-      assert_equal(XML::Reader::TYPE_END_ELEMENT, parser.node_type)
-    end
-  end
-  def test_expand
-    reader = XML::Reader.file(XML_FILE)
-    reader.read.to_s
-    reader.read
-    # Read a node
-    node = reader.expand
-    assert_equal('feed', node.name)
-    assert_equal(::Encoding::UTF_8, node.name.encoding) if defined?(::Encoding)
-  end
-  def test_expand_doc
-    reader = XML::Reader.file(XML_FILE)
-    reader.read.to_s
-    reader.read
-    # Read a node
-    node = reader.expand
-    # Try to access the document
-    refute_nil(node.doc)
-  end
-  def test_expand_find
-    reader = XML::Reader.file(XML_FILE)
-    reader.read.to_s
-    reader.read
-    # Read first node which
-    node = reader.expand
-    assert_equal('feed', node.name)
-    # We need to create document to use xpath
-    reader.doc
-    # Search for entries
-    entries = node.find('atom:entry', 'atom:http://www.w3.org/2005/Atom')
-    assert_equal(1, entries.length)
-  end
-  def test_expand_invalid
-    reader = XML::Reader.file(XML_FILE)
-    # Expand a node before one has been read
-    node = reader.expand
-    assert_nil(node)
-  end
-  def test_expand_should_be_invalid
-    reader = XML::Reader.file(XML_FILE)
-    # Read a couple of nodes
-    reader.read
-    reader.read
-    # Expand the node
-    node = reader.expand
-    assert_equal('feed', node.name)
-    # Read another node, this makes the last node invalid
-    reader.next
-    # The previous node is now invalid - this should be an error but isn't
-    assert_equal('feed', node.name)
-  end
-  def test_mode
-    reader = XML::Reader.string('<xml/>')
-    assert_equal(XML::Reader::MODE_INITIAL, reader.read_state)
-    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(428, reader.byte_consumed)
-  end
-  def test_node
-    XML.default_line_numbers = true
-    reader = XML::Reader.file(XML_FILE)
-    # first try to get a node
-    assert_nil(reader.node)
-    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 = "<?xml version=\"1.0\" encoding=\"utf-8\"?><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")
-    assert_equal(::Encoding::UTF_8, reader.base_uri.encoding) if defined?(::Encoding)
-  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 = "<?xml version=\"1.0\" encoding=\"iso-8859-1\"?><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
-    if defined?(Encoding)
-      assert_equal(Encoding::ISO8859_1, reader.read_outer_xml.encoding)
-      assert_equal(Encoding::ISO8859_1, reader.read_inner_xml.encoding)
-      assert_equal(Encoding::ISO8859_1, reader.read_string.encoding)
-      assert_equal("<bands genre=\"metal\">\n  <m\xC3\xB6tley_cr\xC3\xBCe country=\"us\">An American heavy metal band formed in Los Angeles, California in 1981.</m\xC3\xB6tley_cr\xC3\xBCe>\n  <iron_maiden country=\"uk\">British heavy metal band formed in 1975.</iron_maiden>\n</bands>".force_encoding(Encoding::ISO8859_1),
-                   reader.read_outer_xml)
-      assert_equal("\n  <m\xC3\xB6tley_cr\xC3\xBCe country=\"us\">An American heavy metal band formed in Los Angeles, California in 1981.</m\xC3\xB6tley_cr\xC3\xBCe>\n  <iron_maiden country=\"uk\">British heavy metal band formed in 1975.</iron_maiden>\n".force_encoding(Encoding::ISO8859_1),
-                   reader.read_inner_xml)
-      assert_equal("\n  An American heavy metal band formed in Los Angeles, California in 1981.\n  British heavy metal band formed in 1975.\n".force_encoding(Encoding::ISO8859_1),
-                   reader.read_string)
-    else
-      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
-  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_raises(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(XML::Encoding::UTF_8, reader.encoding)
-    assert_equal(Encoding::UTF_8, reader.value.encoding) if defined?(Encoding)
-  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_xml.rb DELETED Viewed

@@ -1,225 +0,0 @@
-# encoding: UTF-8
-require './test_helper'
-require 'stringio'
-class TestXml < Minitest::Test
-  # -----  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