libxml-ruby 1.1.4 → 2.0.0

data/test/tc_parser_context.rb

@@ -1,186 +1,189 @@
-require "xml"
-require 'test/unit'
-
-class TestParserContext < Test::Unit::TestCase
-  def test_string
-    # UTF8
-    xml = <<-EOS
-      <bands>
-        <metal>m\303\266tley_cr\303\274e</metal>
-      </bands>
-    EOS
-
-    context = XML::Parser::Context.string(xml)
-    assert_instance_of(XML::Parser::Context, context)
-    assert_equal(XML::Encoding::NONE, context.encoding)
-    assert_nil(context.base_uri)
-  end
-
-  def test_encoding
-    # ISO_8859_1:
-    xml = <<-EOS
-      <bands>
-        <metal>m\366tley_cr\374e</metal>
-      </bands>
-    EOS
-
-    context = XML::Parser::Context.string(xml)
-    assert_equal(XML::Encoding::NONE, context.encoding)
-
-    context.encoding = XML::Encoding::ISO_8859_1
-    assert_equal(XML::Encoding::ISO_8859_1, context.encoding)
-  end
-
-  def test_base_uri
-    # UTF8
-    xml = <<-EOS
-      <bands>
-        <metal>m\303\266tley_cr\303\274e</metal>
-      </bands>
-    EOS
-
-    context = XML::Parser::Context.string(xml)
-    assert_nil(context.base_uri)
-
-    context.base_uri = 'http://libxml.rubyforge.org'
-    assert_equal('http://libxml.rubyforge.org', context.base_uri)
-  end
-
-  def test_string_empty
-    error = assert_raise(TypeError) do
-      parser = XML::Parser::Context.string(nil)
-    end
-    assert_equal("wrong argument type nil (expected String)", error.to_s)
-
-    error = assert_raise(ArgumentError) do
-      XML::Parser::Context.string('')
-    end
-    assert_equal("Must specify a string with one or more characters", error.to_s)
-  end
-
-  def test_well_formed
-    parser = XML::Parser.string("<abc/>")
-    parser.parse
-    assert(parser.context.well_formed?)
-  end
-
-  def test_not_well_formed
-    parser = XML::Parser.string("<abc>")
-    assert_raise(XML::Error) do
-      parser.parse
-    end
-    assert(!parser.context.well_formed?)
-  end
-
-  def test_version_info
-    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/bands.xml'))
-    parser = XML::Parser.file(file)
-    assert_nil(parser.context.version)
-    parser.parse
-    assert_equal("1.0", parser.context.version)
-  end
-
-  def test_depth
-    context = XML::Parser::Context.new
-    assert_instance_of(Fixnum, context.depth)
-  end
-
-  def test_disable_sax
-    context = XML::Parser::Context.new
-    assert(!context.disable_sax?)
-  end
-
-  def test_docbook
-    context = XML::Parser::Context.new
-    assert(!context.docbook?)
-  end
-
-  def test_html
-    context = XML::Parser::Context.new
-    assert(!context.html?)
-  end
-
-  def test_keep_blanks
-    context = XML::Parser::Context.new
-    if context.keep_blanks?
-      assert_instance_of(TrueClass, context.keep_blanks?)
-    else
-      assert_instance_of(FalseClass, context.keep_blanks?)
-    end
-  end
-
-  if ENV['NOTWORKING']
-    def test_num_chars
-      assert_equal(17, context.num_chars)
-    end
-  end
-
-  def test_replace_entities
-    context = XML::Parser::Context.new
-    assert(!context.replace_entities?)
-
-#    context.options = 1
- #   assert(context.replace_entities?)
-
-    context.options = 0
-    assert(!context.replace_entities?)
-
-    context.replace_entities = true
-    assert(context.replace_entities?)
-  end
-
-  def test_space_depth
-    context = XML::Parser::Context.new
-    assert_equal(1, context.space_depth)
-  end
-
-  def test_subset_external
-    context = XML::Parser::Context.new
-    assert(!context.subset_external?)
-  end
-
-  def test_data_directory_get
-    context = XML::Parser::Context.new
-    assert_nil(context.data_directory)
-  end
-
-  def test_parse_error
-    xp = XML::Parser.string('<foo><bar/></foz>')
-
-    assert_raise(XML::Error) do
-      xp.parse
-    end
-
-    # Now check context
-    context = xp.context
-    assert_equal(nil, context.data_directory)
-    assert_equal(0, context.depth)
-    assert_equal(true, context.disable_sax?)
-    assert_equal(false, context.docbook?)
-    assert_equal(XML::Encoding::NONE, context.encoding)
-    assert_equal(76, context.errno)
-    assert_equal(false, context.html?)
-    assert_equal(5, context.io_max_num_streams)
-    assert_equal(1, context.io_num_streams)
-    assert_equal(true, context.keep_blanks?)
-    assert_equal(1, context.io_num_streams)
-    assert_equal(nil, context.name_node)
-    assert_equal(0, context.name_depth)
-    assert_equal(10, context.name_depth_max)
-    assert_equal(17, context.num_chars)
-    assert_equal(false, context.replace_entities?)
-    assert_equal(1, context.space_depth)
-    assert_equal(10, context.space_depth_max)
-    assert_equal(false, context.subset_external?)
-    assert_equal(nil, context.subset_external_system_id)
-    assert_equal(nil, context.subset_external_uri)
-    assert_equal(false, context.subset_internal?)
-    assert_equal(nil, context.subset_internal_name)
-    assert_equal(false, context.stats?)
-    assert_equal(true, context.standalone?)
-    assert_equal(false, context.valid)
-    assert_equal(false, context.validate?)
-    assert_equal('1.0', context.version)
-    assert_equal(false, context.well_formed?)
-  end
+# encoding: UTF-8
+
+require './test_helper'
+
+require 'test/unit'
+
+class TestParserContext < Test::Unit::TestCase
+  def test_string
+    # UTF8
+    xml = <<-EOS
+      <bands>
+        <metal>m\303\266tley_cr\303\274e</metal>
+      </bands>
+    EOS
+
+    context = XML::Parser::Context.string(xml)
+    assert_instance_of(XML::Parser::Context, context)
+    assert_equal(XML::Encoding::NONE, context.encoding)
+    assert_nil(context.base_uri)
+  end
+
+  def test_encoding
+    # ISO_8859_1:
+    xml = <<-EOS
+      <bands>
+        <metal>m\366tley_cr\374e</metal>
+      </bands>
+    EOS
+
+    context = XML::Parser::Context.string(xml)
+    assert_equal(XML::Encoding::NONE, context.encoding)
+
+    context.encoding = XML::Encoding::ISO_8859_1
+    assert_equal(XML::Encoding::ISO_8859_1, context.encoding)
+  end
+
+  def test_base_uri
+    # UTF8
+    xml = <<-EOS
+      <bands>
+        <metal>m\303\266tley_cr\303\274e</metal>
+      </bands>
+    EOS
+
+    context = XML::Parser::Context.string(xml)
+    assert_nil(context.base_uri)
+
+    context.base_uri = 'http://libxml.rubyforge.org'
+    assert_equal('http://libxml.rubyforge.org', context.base_uri)
+  end
+
+  def test_string_empty
+    error = assert_raise(TypeError) do
+      parser = XML::Parser::Context.string(nil)
+    end
+    assert_equal("wrong argument type nil (expected String)", error.to_s)
+
+    error = assert_raise(ArgumentError) do
+      XML::Parser::Context.string('')
+    end
+    assert_equal("Must specify a string with one or more characters", error.to_s)
+  end
+
+  def test_well_formed
+    parser = XML::Parser.string("<abc/>")
+    parser.parse
+    assert(parser.context.well_formed?)
+  end
+
+  def test_not_well_formed
+    parser = XML::Parser.string("<abc>")
+    assert_raise(XML::Error) do
+      parser.parse
+    end
+    assert(!parser.context.well_formed?)
+  end
+
+  def test_version_info
+    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/bands.utf-8.xml'))
+    parser = XML::Parser.file(file)
+    assert_nil(parser.context.version)
+    parser.parse
+    assert_equal("1.0", parser.context.version)
+  end
+
+  def test_depth
+    context = XML::Parser::Context.new
+    assert_instance_of(Fixnum, context.depth)
+  end
+
+  def test_disable_sax
+    context = XML::Parser::Context.new
+    assert(!context.disable_sax?)
+  end
+
+  def test_docbook
+    context = XML::Parser::Context.new
+    assert(!context.docbook?)
+  end
+
+  def test_html
+    context = XML::Parser::Context.new
+    assert(!context.html?)
+  end
+
+  def test_keep_blanks
+    context = XML::Parser::Context.new
+    if context.keep_blanks?
+      assert_instance_of(TrueClass, context.keep_blanks?)
+    else
+      assert_instance_of(FalseClass, context.keep_blanks?)
+    end
+  end
+
+  if ENV['NOTWORKING']
+    def test_num_chars
+      assert_equal(17, context.num_chars)
+    end
+  end
+
+  def test_replace_entities
+    context = XML::Parser::Context.new
+    assert(!context.replace_entities?)
+
+#    context.options = 1
+ #   assert(context.replace_entities?)
+
+    context.options = 0
+    assert(!context.replace_entities?)
+
+    context.replace_entities = true
+    assert(context.replace_entities?)
+  end
+
+  def test_space_depth
+    context = XML::Parser::Context.new
+    assert_equal(1, context.space_depth)
+  end
+
+  def test_subset_external
+    context = XML::Parser::Context.new
+    assert(!context.subset_external?)
+  end
+
+  def test_data_directory_get
+    context = XML::Parser::Context.new
+    assert_nil(context.data_directory)
+  end
+
+  def test_parse_error
+    xp = XML::Parser.string('<foo><bar/></foz>')
+
+    assert_raise(XML::Error) do
+      xp.parse
+    end
+
+    # Now check context
+    context = xp.context
+    assert_equal(nil, context.data_directory)
+    assert_equal(0, context.depth)
+    assert_equal(true, context.disable_sax?)
+    assert_equal(false, context.docbook?)
+    assert_equal(XML::Encoding::NONE, context.encoding)
+    assert_equal(76, context.errno)
+    assert_equal(false, context.html?)
+    assert_equal(5, context.io_max_num_streams)
+    assert_equal(1, context.io_num_streams)
+    assert_equal(true, context.keep_blanks?)
+    assert_equal(1, context.io_num_streams)
+    assert_equal(nil, context.name_node)
+    assert_equal(0, context.name_depth)
+    assert_equal(10, context.name_depth_max)
+    assert_equal(17, context.num_chars)
+    assert_equal(false, context.replace_entities?)
+    assert_equal(1, context.space_depth)
+    assert_equal(10, context.space_depth_max)
+    assert_equal(false, context.subset_external?)
+    assert_equal(nil, context.subset_external_system_id)
+    assert_equal(nil, context.subset_external_uri)
+    assert_equal(false, context.subset_internal?)
+    assert_equal(nil, context.subset_internal_name)
+    assert_equal(false, context.stats?)
+    assert_equal(true, context.standalone?)
+    assert_equal(false, context.valid)
+    assert_equal(false, context.validate?)
+    assert_equal('1.0', context.version)
+    assert_equal(false, context.well_formed?)
+  end
 end

data/test/tc_properties.rb

@@ -1,36 +1,39 @@
-require "xml"
-require 'test/unit'
-
-# Properties is deprecated - use attributes instead.
-# Tests for backwards compatibility
-
-class TestProperties < Test::Unit::TestCase
-  def setup()
-    xp = XML::Parser.string('<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>')
-    @doc = xp.parse
-  end
-
-  def teardown()
-    @doc = nil
-  end
-
-  def test_traversal
-    properties = @doc.root.properties
-    
-    assert_instance_of(XML::Attributes, properties)
-    attribute = properties.first
-    assert_equal('uga', attribute.name)
-    assert_equal('booga', attribute.value)
-
-    attribute = attribute.next
-    assert_instance_of(XML::Attr, attribute)
-    assert_equal('foo', attribute.name)
-    assert_equal('bar', attribute.value)
-  end
-  
-  def test_no_properties
-    properties = @doc.root.child.properties
-    assert_instance_of(XML::Attributes, properties)
-    assert_equal(0, properties.length)
-  end
-end
+# encoding: UTF-8
+
+require './test_helper'
+
+require 'test/unit'
+
+# attributes is deprecated - use attributes instead.
+# Tests for backwards compatibility
+
+class Testattributes < Test::Unit::TestCase
+  def setup()
+    xp = XML::Parser.string('<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>')
+    @doc = xp.parse
+  end
+
+  def teardown()
+    @doc = nil
+  end
+
+  def test_traversal
+    attributes = @doc.root.attributes
+    
+    assert_instance_of(XML::Attributes, attributes)
+    attribute = attributes.first
+    assert_equal('uga', attribute.name)
+    assert_equal('booga', attribute.value)
+
+    attribute = attribute.next
+    assert_instance_of(XML::Attr, attribute)
+    assert_equal('foo', attribute.name)
+    assert_equal('bar', attribute.value)
+  end
+  
+  def test_no_attributes
+    attributes = @doc.root.child.attributes
+    assert_instance_of(XML::Attributes, attributes)
+    assert_equal(0, attributes.length)
+  end
+end

data/test/tc_reader.rb

@@ -1,284 +1,298 @@
-require 'xml'
-require 'stringio'
-require 'test/unit'
-
-class TestReader < Test::Unit::TestCase
-  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_raise(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_raise(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_deprecated_error_handler
-    called = false
-    reader = XML::Reader.string('<foo blah')
-    reader.set_error_handler do |error|
-      called = true
-    end
-
-    assert_raise(XML::Error) do
-      reader.read
-    end
-
-    assert(called)
-  end
-
-  def test_deprecated_reset_error_handler
-    called = false
-    reader = XML::Reader.string('<foo blah')
-    reader.set_error_handler do |error|
-      called = true
-    end
-    reader.reset_error_handler
-
-    assert_raise(XML::Error) do
-      reader.read
-    end
-
-    assert(!called)
-  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_equal(nil, parser['z'])
-    assert_equal(nil, parser[2])
-  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
-    node = reader.expand
-    doc = node.doc
-    reader.close
-    GC.start
-
-    doc.standalone?
-  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(416, 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 = "<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")
-  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 = "<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
-
-    # libxml converts all data sources to utf8 internally
-    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
-
-  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_raise(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(reader.encoding, XML::Encoding::UTF_8)
-  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
+# encoding: UTF-8
+
+require './test_helper'
+require 'stringio'
+require 'test/unit'
+
+class TestReader < Test::Unit::TestCase
+  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_raise(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_raise(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_deprecated_error_handler
+    called = false
+    reader = XML::Reader.string('<foo blah')
+    reader.set_error_handler do |error|
+      called = true
+    end
+
+    assert_raise(XML::Error) do
+      reader.read
+    end
+
+    assert(called)
+  end
+
+  def test_deprecated_reset_error_handler
+    called = false
+    reader = XML::Reader.string('<foo blah')
+    reader.set_error_handler do |error|
+      called = true
+    end
+    reader.reset_error_handler
+
+    assert_raise(XML::Error) do
+      reader.read
+    end
+
+    assert(!called)
+  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_equal(nil, parser['z'])
+    assert_equal(nil, parser[2])
+  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
+    node = reader.expand
+    assert_nil(node.doc)
+    reader.close
+    GC.start
+  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(416, 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_raise(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