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

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