caring-nokogiri 1.4.1.pre1

data/test/html/test_node_encoding.rb

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+require "helper"
+
+module Nokogiri
+  module HTML
+    if RUBY_VERSION =~ /^1\.9/
+      class TestNodeEncoding < Nokogiri::TestCase
+        def test_inner_html
+          doc = Nokogiri::HTML File.open(SHIFT_JIS_HTML, 'rb')
+
+          hello = "こんにちは"
+
+          contents = doc.at('h2').inner_html
+          assert_equal doc.encoding, contents.encoding.name
+          assert_match hello.encode('Shift_JIS'), contents
+
+          contents = doc.at('h2').inner_html(:encoding => 'UTF-8')
+          assert_match hello, contents
+
+          doc.encoding = 'UTF-8'
+          contents = doc.at('h2').inner_html
+          assert_match hello, contents
+        end
+      end
+    end
+  end
+end

data/test/test_convert_xpath.rb

@@ -0,0 +1,135 @@
+require "helper"
+
+class TestConvertXPath < Nokogiri::TestCase
+
+  def setup
+    super
+    @N = Nokogiri(File.read(HTML_FILE))
+  end
+
+  def assert_syntactical_equivalence(hpath, xpath, match, &blk)
+    blk ||= lambda {|j| j.first}
+    assert_equal match, blk.call(@N.search(xpath)), "xpath result did not match"
+  end
+
+  def test_child_tag
+    assert_syntactical_equivalence("h1[a]", ".//h1[child::a]", "Tender Lovemaking") do |j|
+      j.inner_text
+    end
+  end
+
+  def test_child_tag_equals
+    assert_syntactical_equivalence("h1[a='Tender Lovemaking']", ".//h1[child::a = 'Tender Lovemaking']", "Tender Lovemaking") do |j|
+      j.inner_text
+    end
+  end
+
+  def test_filter_contains
+    assert_syntactical_equivalence("title:contains('Tender')", ".//title[contains(., 'Tender')]",
+                                   "Tender Lovemaking  ") do |j|
+      j.inner_text
+    end
+  end
+
+  def test_filter_comment
+    assert_syntactical_equivalence("div comment()[2]", ".//div//comment()[position() = 2]", "<!-- end of header -->") do |j|
+      j.first.to_s
+    end
+  end
+
+  def test_filter_text
+    assert_syntactical_equivalence("a[text()]", ".//a[normalize-space(child::text())]", "<a href=\"http://tenderlovemaking.com\">Tender Lovemaking</a>") do |j|
+      j.first.to_s
+    end
+    assert_syntactical_equivalence("a[text()='Tender Lovemaking']", ".//a[normalize-space(child::text()) = 'Tender Lovemaking']", "<a href=\"http://tenderlovemaking.com\">Tender Lovemaking</a>") do |j|
+      j.first.to_s
+    end
+    assert_syntactical_equivalence("a/text()", ".//a/child::text()", "Tender Lovemaking") do |j|
+      j.first.to_s
+    end
+    assert_syntactical_equivalence("h2//a[text()!='Back Home!']", ".//h2//a[normalize-space(child::text()) != 'Back Home!']", "Meow meow meow meow meow") do |j|
+      j.first.inner_text
+    end
+  end
+
+  def test_filter_by_attr
+    assert_syntactical_equivalence("a[@href='http://blog.geminigeek.com/wordpress-theme']",
+                                   ".//a[@href = 'http://blog.geminigeek.com/wordpress-theme']",
+                                   "http://blog.geminigeek.com/wordpress-theme") do |j|
+      j.first["href"]
+    end
+  end
+
+  def test_css_id
+    assert_syntactical_equivalence("#linkcat-7", ".//*[@id = 'linkcat-7']", "linkcat-7") do |j|
+      j.first["id"]
+    end
+    assert_syntactical_equivalence("li#linkcat-7", ".//li[@id = 'linkcat-7']", "linkcat-7") do |j|
+      j.first["id"]
+    end
+  end
+
+  def test_css_class
+    assert_syntactical_equivalence(".cat-item-15", ".//*[contains(concat(' ', @class, ' '), ' cat-item-15 ')]",
+                                   "cat-item cat-item-15") do |j|
+      j.first["class"]
+    end
+    assert_syntactical_equivalence("li.cat-item-15", ".//li[contains(concat(' ', @class, ' '), ' cat-item-15 ')]",
+                                   "cat-item cat-item-15") do |j|
+      j.first["class"]
+    end
+  end
+
+  def test_css_tags
+    assert_syntactical_equivalence("div li a", ".//div//li//a", "http://brobinius.org/") do |j|
+      j.first.inner_text
+    end
+    assert_syntactical_equivalence("div li > a", ".//div//li/a", "http://brobinius.org/") do |j|
+      j.first.inner_text
+    end
+    assert_syntactical_equivalence("h1 ~ small", ".//small[preceding-sibling::h1]", "The act of making love, tenderly.") do |j|
+      j.first.inner_text
+    end
+    assert_syntactical_equivalence("h1 ~ small", ".//small[preceding-sibling::h1]", "The act of making love, tenderly.") do |j|
+      j.first.inner_text
+    end
+  end
+
+  def test_positional
+    assert_syntactical_equivalence("div/div:first()", ".//div/div[position() = 1]", "\r\nTender Lovemaking\r\nThe act of making love, tenderly.\r\n".gsub(/[\r\n]/, '')) do |j|
+      j.first.inner_text.gsub(/[\r\n]/, '')
+    end
+    assert_syntactical_equivalence("div/div:first", ".//div/div[position() = 1]", "\r\nTender Lovemaking\r\nThe act of making love, tenderly.\r\n".gsub(/[\r\n]/, '')) do |j|
+      j.first.inner_text.gsub(/[\r\n]/, '')
+    end
+    assert_syntactical_equivalence("div//a:last()", ".//div//a[position() = last()]", "Wordpress") do |j|
+      j.last.inner_text
+    end
+    assert_syntactical_equivalence("div//a:last", ".//div//a[position() = last()]", "Wordpress") do |j|
+      j.last.inner_text
+    end
+  end
+
+  def test_multiple_filters
+    assert_syntactical_equivalence("a[@rel='bookmark'][1]", ".//a[@rel = 'bookmark' and position() = 1]", "Back Home!") do |j|
+      j.first.inner_text
+    end
+  end
+
+# TODO:
+#       doc/'title ~ link' -> links that are siblings of title
+#       doc/'p[@class~="final"]' -> class includes string (whitespacy)
+#       doc/'p[text()*="final"]' -> class includes string (index) (broken: always returns true?)
+#       doc/'p[text()$="final"]' -> /final$/
+#       doc/'p[text()|="final"]' -> /^final$/
+#       doc/'p[text()^="final"]' -> string starts with 'final
+#       nth_first
+#       nth_last
+#       even
+#       odd
+#       first-child, nth-child, last-child, nth-last-child, nth-last-of-type
+#       only-of-type, only-child
+#       parent
+#       empty
+#       root
+end

data/test/test_css_cache.rb

@@ -0,0 +1,45 @@
+require "helper"
+
+class TestCssCache < Nokogiri::TestCase
+
+  def setup
+    super
+    @css = "a1 > b2 > c3"
+    @parse_result = Nokogiri::CSS.parse(@css)
+    @to_xpath_result = @parse_result.map {|ast| ast.to_xpath}
+    Nokogiri::CSS::Parser.class_eval do
+      class << @cache
+        alias :old_bracket :[]
+        attr_reader :count
+        def [](key)
+          @count ||= 0
+          @count += 1
+          old_bracket(key)
+        end
+      end
+    end
+    assert Nokogiri::CSS::Parser.cache_on?
+  end
+
+  def teardown
+    Nokogiri::CSS::Parser.clear_cache
+    Nokogiri::CSS::Parser.set_cache true
+  end
+
+  [ false, true ].each do |cache_setting|
+    define_method "test_css_cache_#{cache_setting ? "true" : "false"}" do
+      times = cache_setting ? 4 : nil
+
+      Nokogiri::CSS::Parser.set_cache cache_setting
+
+      Nokogiri::CSS.xpath_for(@css)
+      Nokogiri::CSS.xpath_for(@css)
+      Nokogiri::CSS::Parser.new.xpath_for(@css)
+      Nokogiri::CSS::Parser.new.xpath_for(@css)
+
+      assert_equal(times, Nokogiri::CSS::Parser.class_eval { @cache.count })
+    end
+  end
+
+
+end

data/test/test_gc.rb

@@ -0,0 +1,15 @@
+require "helper"
+
+class TestGc < Nokogiri::TestCase
+
+  def test_dont_hurt_em_why
+    content = File.open("#{File.dirname(__FILE__)}/files/dont_hurt_em_why.xml").read
+    ndoc = Nokogiri::XML(content)
+    2.times do
+      info = ndoc.search('status text').first.inner_text
+      url = ndoc.search('user name').first.inner_text
+      GC.start
+    end
+  end
+
+end

data/test/test_memory_leak.rb

@@ -0,0 +1,77 @@
+require "helper"
+
+class TestMemoryLeak < Nokogiri::TestCase
+
+  if ENV['NOKOGIRI_GC'] # turning these off by default for now
+
+    def test_for_memory_leak
+      begin
+        #  we don't use Dike in any tests, but requiring it has side effects
+        #  that can create memory leaks, and that's what we're testing for.
+        require 'rubygems'
+        require 'dike' # do not remove!
+
+        count_start = count_object_space_documents
+        xml_data = <<-EOS
+        <test>
+          <items>
+            <item>abc</item>
+            <item>1234</item>
+            <item>Zzz</item>
+          <items>
+        </test>
+        EOS
+        20.times do
+          doc = Nokogiri::XML(xml_data)
+          doc.xpath("//item")
+        end
+        2.times { GC.start }
+        count_end = count_object_space_documents
+        assert((count_end - count_start) <= 2, "memory leak detected")
+      rescue LoadError
+        puts "\ndike is not installed, skipping memory leak test"
+      end
+    end
+
+    if Nokogiri.ffi?
+      [ ['Node', 'p', nil],
+        ['CDATA', nil, 'content'],
+        ['Comment', nil, 'content'],
+        ['DocumentFragment', nil],
+        ['EntityReference', nil, 'p'],
+        ['ProcessingInstruction', nil, 'p', 'content'] ].each do |klass, *args|
+
+        define_method "test_for_leaked_#{klass}_nodes" do
+          Nokogiri::LibXML.expects(:xmlAddChild).at_least(1) # more than once shows we're GCing properly
+          10.times {
+            xml = Nokogiri::XML("<root></root>")
+            2.times { Nokogiri::XML.const_get(klass).new(*(args.collect{|arg| arg || xml})) }
+            GC.start
+          }
+          GC.start
+        end
+
+      end
+
+      def test_for_leaked_attr_nodes
+        Nokogiri::LibXML.expects(:xmlFreePropList).at_least(1) # more than once shows we're GCing properly
+        10.times {
+          xml = Nokogiri::XML("<root></root>")
+          2.times { Nokogiri::XML::Attr.new(xml, "p") }
+          GC.start
+        }
+        GC.start
+      end
+
+    end # if ffi
+
+  end # if NOKOGIRI_GC
+
+  private
+
+  def count_object_space_documents
+    count = 0
+    ObjectSpace.each_object {|j| count += 1 if j.is_a?(Nokogiri::XML::Document) }
+    count
+  end
+end

data/test/test_nokogiri.rb

@@ -0,0 +1,138 @@
+require "helper"
+
+class TestNokogiri < Nokogiri::TestCase
+  def test_versions
+    version_match = /\d+\.\d+\.\d+/
+    assert_match version_match, Nokogiri::VERSION
+    assert_match version_match, Nokogiri::LIBXML_VERSION
+
+    if defined?(FFI)
+      assert_equal 'ffi', Nokogiri::VERSION_INFO['libxml']['binding']
+      if RUBY_PLATFORM =~ /java/
+        assert_equal 'jruby', Nokogiri::VERSION_INFO['libxml']['platform']
+      else
+        assert_equal 'ruby', Nokogiri::VERSION_INFO['libxml']['platform']
+      end
+      assert Nokogiri.ffi?
+    else
+      assert_equal 'extension', Nokogiri::VERSION_INFO['libxml']['binding']
+
+      assert_match version_match, Nokogiri::VERSION_INFO['libxml']['compiled']
+      assert_equal Nokogiri::LIBXML_VERSION, Nokogiri::VERSION_INFO['libxml']['compiled']
+      assert ! Nokogiri.ffi?
+    end
+
+    assert_match version_match, Nokogiri::VERSION_INFO['libxml']['loaded']
+    Nokogiri::LIBXML_PARSER_VERSION =~ /(\d)(\d{2})(\d{2})/
+    major = $1.to_i
+    minor = $2.to_i
+    bug   = $3.to_i
+    assert_equal "#{major}.#{minor}.#{bug}", Nokogiri::VERSION_INFO['libxml']['loaded']
+  end
+
+  def test_libxml_iconv
+    assert Nokogiri.const_defined?(:LIBXML_ICONV_ENABLED)
+  end
+
+  def test_parse_with_io
+    doc = Nokogiri.parse(
+      StringIO.new("<html><head><title></title><body></body></html>")
+    )
+    assert_instance_of Nokogiri::HTML::Document, doc
+  end
+
+  def test_xml?
+    doc = Nokogiri.parse(File.read(XML_FILE))
+    assert doc.xml?
+    assert !doc.html?
+  end
+
+  def test_html?
+    doc = Nokogiri.parse(File.read(HTML_FILE))
+    assert !doc.xml?
+    assert doc.html?
+  end
+
+  def test_nokogiri_method_with_html
+    doc1 = Nokogiri(File.read(HTML_FILE))
+    doc2 = Nokogiri.parse(File.read(HTML_FILE))
+    assert_equal doc1.serialize, doc2.serialize
+  end
+
+  def test_nokogiri_method_with_block
+    doc = Nokogiri { b "bold tag" }
+    assert_equal('<b>bold tag</b>', doc.to_html.chomp)
+  end
+
+  def test_make_with_html
+    doc = Nokogiri.make("<b>bold tag</b>")
+    assert_equal('<b>bold tag</b>', doc.to_html.chomp)
+  end
+
+  def test_make_with_block
+    doc = Nokogiri.make { b "bold tag" }
+    assert_equal('<b>bold tag</b>', doc.to_html.chomp)
+  end
+
+  SLOP_HTML = <<-END
+  <html>
+    <body>
+      <ul>
+        <li class='red'>one</li>
+        <li class='blue'>two</li>
+      </ul>
+      <div>
+        one
+        <div>div two</div>
+      </div>
+    </body>
+  </html>
+  END
+
+  def test_slop_css
+    doc = Nokogiri::Slop(<<-eohtml)
+    <html>
+      <body>
+        <div>
+          one
+          <div class='foo'>
+            div two
+            <div class='foo'>
+              div three
+            </div>
+          </div>
+        </div>
+      </body>
+    </html>
+    eohtml
+    assert_equal "div", doc.html.body.div.div('.foo').name
+  end
+
+  def test_slop
+    doc = Nokogiri::Slop(SLOP_HTML)
+
+    assert_equal "one", doc.html.body.ul.li.first.text
+    assert_equal "two", doc.html.body.ul.li(".blue").text
+    assert_equal "div two", doc.html.body.div.div.text
+
+    assert_equal "two", doc.html.body.ul.li(:css => ".blue").text
+
+    assert_equal "two", doc.html.body.ul.li(:xpath => "position()=2").text
+    assert_equal "one", doc.html.body.ul.li(:xpath => ["contains(text(),'o')"]).first.text
+    assert_equal "two", doc.html.body.ul.li(:xpath => ["contains(text(),'o')","contains(text(),'t')"]).text
+
+    assert_raise(NoMethodError) { doc.nonexistent }
+  end
+
+  def test_slop_decorator
+    doc = Nokogiri(SLOP_HTML)
+    assert !doc.decorators(Nokogiri::XML::Node).include?(Nokogiri::Decorators::Slop)
+
+    doc.slop!
+    assert doc.decorators(Nokogiri::XML::Node).include?(Nokogiri::Decorators::Slop)
+
+    doc.slop!
+    assert_equal 1, doc.decorators(Nokogiri::XML::Node).select { |d| d == Nokogiri::Decorators::Slop }.size
+  end
+
+end

data/test/test_reader.rb

@@ -0,0 +1,358 @@
+# -*- coding: utf-8 -*-
+require "helper"
+
+class TestReader < Nokogiri::TestCase
+  def test_from_io_sets_io_as_source
+    io = File.open SNUGGLES_FILE
+    reader = Nokogiri::XML::Reader.from_io(io)
+    assert_equal io, reader.source
+  end
+
+  def test_reader_takes_block
+    options = nil
+    Nokogiri::XML::Reader(File.read(XML_FILE), XML_FILE) do |cfg|
+      options = cfg
+      options.nonet.nowarning.dtdattr
+    end
+    assert options.nonet?
+    assert options.nowarning?
+    assert options.dtdattr?
+  end
+
+  def test_nil_raises
+    assert_raises(ArgumentError) {
+      Nokogiri::XML::Reader.from_memory(nil)
+    }
+    assert_raises(ArgumentError) {
+      Nokogiri::XML::Reader.from_io(nil)
+    }
+  end
+
+  def test_from_io
+    io = File.open SNUGGLES_FILE
+    reader = Nokogiri::XML::Reader.from_io(io)
+    assert_equal false, reader.default?
+    assert_equal [false, false, false, false, false, false, false],
+      reader.map { |x| x.default? }
+  end
+
+  def test_io
+    io = File.open SNUGGLES_FILE
+    reader = Nokogiri::XML::Reader(io)
+    assert_equal false, reader.default?
+    assert_equal [false, false, false, false, false, false, false],
+      reader.map { |x| x.default? }
+  end
+
+  def test_string_io
+    io = StringIO.new(<<-eoxml)
+    <x xmlns:tenderlove='http://tenderlovemaking.com/'>
+      <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
+    </x>
+    eoxml
+    reader = Nokogiri::XML::Reader(io)
+    assert_equal false, reader.default?
+    assert_equal [false, false, false, false, false, false, false],
+      reader.map { |x| x.default? }
+  end
+
+  def test_in_memory
+    reader = Nokogiri::XML::Reader(<<-eoxml)
+    <x xmlns:tenderlove='http://tenderlovemaking.com/'>
+      <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
+    </x>
+    eoxml
+  end
+
+  def test_reader_holds_on_to_string
+    xml = <<-eoxml
+    <x xmlns:tenderlove='http://tenderlovemaking.com/'>
+      <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
+    </x>
+    eoxml
+    reader = Nokogiri::XML::Reader(xml)
+    if Nokogiri.ffi?
+      assert_not_nil reader.source
+      assert reader.source.is_a?(FFI::MemoryPointer)
+    else
+      assert_equal xml, reader.source
+    end
+  end
+
+  def test_default?
+    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
+    <x xmlns:tenderlove='http://tenderlovemaking.com/'>
+      <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
+    </x>
+    eoxml
+    assert_equal false, reader.default?
+    assert_equal [false, false, false, false, false, false, false],
+      reader.map { |x| x.default? }
+  end
+
+  def test_value?
+    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
+    <x xmlns:tenderlove='http://tenderlovemaking.com/'>
+      <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
+    </x>
+    eoxml
+    assert_equal false, reader.value?
+    assert_equal [false, true, false, true, false, true, false],
+      reader.map { |x| x.value? }
+  end
+
+  def test_read_error_document
+    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
+    <x xmlns:tenderlove='http://tenderlovemaking.com/'>
+      <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
+      <foo>
+    </x>
+    eoxml
+    error_happened = false
+    begin
+      reader.each { |node| }
+    rescue Nokogiri::XML::SyntaxError => ex
+      error_happened = true
+    end
+    assert error_happened
+    assert 1, reader.errors.length
+  end
+
+  def test_attributes?
+    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
+    <x xmlns:tenderlove='http://tenderlovemaking.com/'>
+      <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
+    </x>
+    eoxml
+    assert_equal false, reader.attributes?
+    assert_equal [true, false, true, false, true, false, true],
+      reader.map { |x| x.attributes? }
+  end
+
+  def test_attributes
+    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
+    <x xmlns:tenderlove='http://tenderlovemaking.com/'
+       xmlns='http://mothership.connection.com/'
+       >
+      <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
+    </x>
+    eoxml
+    assert_equal({}, reader.attributes)
+    assert_equal [{'xmlns:tenderlove'=>'http://tenderlovemaking.com/',
+                   'xmlns'=>'http://mothership.connection.com/'},
+                  {}, {"awesome"=>"true"}, {}, {"awesome"=>"true"}, {},
+                  {'xmlns:tenderlove'=>'http://tenderlovemaking.com/',
+                   'xmlns'=>'http://mothership.connection.com/'}],
+      reader.map { |x| x.attributes }
+  end
+
+  def test_attribute_roundtrip
+    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
+    <x xmlns:tenderlove='http://tenderlovemaking.com/'
+       xmlns='http://mothership.connection.com/'
+       >
+      <tenderlove:foo awesome='true' size='giant'>snuggles!</tenderlove:foo>
+    </x>
+    eoxml
+    reader.each do |node|
+      node.attributes.each do |key, value|
+        assert_equal value, node.attribute(key)
+      end
+    end
+  end
+
+  def test_attribute_at
+    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
+    <x xmlns:tenderlove='http://tenderlovemaking.com/'>
+      <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
+    </x>
+    eoxml
+    assert_nil reader.attribute_at(nil)
+    assert_nil reader.attribute_at(0)
+    assert_equal ['http://tenderlovemaking.com/', nil, 'true', nil, 'true', nil, 'http://tenderlovemaking.com/'],
+      reader.map { |x| x.attribute_at(0) }
+  end
+
+  def test_attribute
+    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
+    <x xmlns:tenderlove='http://tenderlovemaking.com/'>
+      <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
+    </x>
+    eoxml
+    assert_nil reader.attribute(nil)
+    assert_nil reader.attribute('awesome')
+    assert_equal [nil, nil, 'true', nil, 'true', nil, nil],
+      reader.map { |x| x.attribute('awesome') }
+  end
+
+  def test_attribute_length
+    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
+    <x xmlns:tenderlove='http://tenderlovemaking.com/'>
+      <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
+    </x>
+    eoxml
+    assert_equal 0, reader.attribute_count
+    assert_equal [1, 0, 1, 0, 0, 0, 0], reader.map { |x| x.attribute_count }
+  end
+
+  def test_depth
+    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
+    <x xmlns:tenderlove='http://tenderlovemaking.com/'>
+      <tenderlove:foo>snuggles!</tenderlove:foo>
+    </x>
+    eoxml
+    assert_equal 0, reader.depth
+    assert_equal [0, 1, 1, 2, 1, 1, 0], reader.map { |x| x.depth }
+  end
+
+  def test_encoding
+    string = <<-eoxml
+    <awesome>
+      <p xml:lang="en">The quick brown fox jumps over the lazy dog.</p>
+      <p xml:lang="ja">日本語が上手です</p>
+    </awesome>
+    eoxml
+    reader = Nokogiri::XML::Reader.from_memory(string, nil, 'UTF-8')
+    assert_equal ['UTF-8'], reader.map { |x| x.encoding }.uniq
+  end
+
+  def test_xml_version
+    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
+    <x xmlns:tenderlove='http://tenderlovemaking.com/'>
+      <tenderlove:foo>snuggles!</tenderlove:foo>
+    </x>
+    eoxml
+    assert_nil reader.xml_version
+    assert_equal ['1.0'], reader.map { |x| x.xml_version }.uniq
+  end
+
+  def test_lang
+    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
+    <awesome>
+      <p xml:lang="en">The quick brown fox jumps over the lazy dog.</p>
+      <p xml:lang="ja">日本語が上手です</p>
+    </awesome>
+    eoxml
+    assert_nil reader.lang
+    assert_equal [nil, nil, "en", "en", "en", nil, "ja", "ja", "ja", nil, nil],
+      reader.map { |x| x.lang }
+  end
+
+  def test_value
+    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
+    <x xmlns:tenderlove='http://tenderlovemaking.com/'>
+      <tenderlove:foo>snuggles!</tenderlove:foo>
+    </x>
+    eoxml
+    assert_nil reader.value
+    assert_equal [nil, "\n      ", nil, "snuggles!", nil, "\n    ", nil],
+      reader.map { |x| x.value }
+  end
+
+  def test_prefix
+    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
+    <x xmlns:edi='http://ecommerce.example.org/schema'>
+      <edi:foo>hello</edi:foo>
+    </x>
+    eoxml
+    assert_nil reader.prefix
+    assert_equal [nil, nil, "edi", nil, "edi", nil, nil],
+      reader.map { |n| n.prefix }
+  end
+
+  def test_node_type
+    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
+    <x>
+      <y>hello</y>
+    </x>
+    eoxml
+    assert_equal 0, reader.node_type
+    assert_equal [1, 14, 1, 3, 15, 14, 15], reader.map { |n| n.node_type }
+  end
+
+  def test_inner_xml
+    str = "<x><y>hello</y></x>"
+    reader = Nokogiri::XML::Reader.from_memory(str)
+
+    reader.read
+
+    assert_equal "<y>hello</y>", reader.inner_xml
+  end
+
+  def test_outer_xml
+    str = "<x><y>hello</y></x>"
+    reader = Nokogiri::XML::Reader.from_memory(str)
+
+    reader.read
+
+    assert_equal str, reader.outer_xml
+  end
+
+  def test_state
+    reader = Nokogiri::XML::Reader.from_memory('<foo>bar</bar>')
+    assert reader.state
+  end
+
+  def test_ns_uri
+    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
+    <x xmlns:edi='http://ecommerce.example.org/schema'>
+      <edi:foo>hello</edi:foo>
+    </x>
+    eoxml
+    assert_nil reader.namespace_uri
+    assert_equal([nil,
+                  nil,
+                  "http://ecommerce.example.org/schema",
+                  nil,
+                  "http://ecommerce.example.org/schema",
+                  nil,
+                  nil],
+                  reader.map { |n| n.namespace_uri })
+  end
+
+  def test_local_name
+    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
+    <x xmlns:edi='http://ecommerce.example.org/schema'>
+      <edi:foo>hello</edi:foo>
+    </x>
+    eoxml
+    assert_nil reader.local_name
+    assert_equal(["x", "#text", "foo", "#text", "foo", "#text", "x"],
+                 reader.map { |n| n.local_name })
+  end
+
+  def test_name
+    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
+    <x xmlns:edi='http://ecommerce.example.org/schema'>
+      <edi:foo>hello</edi:foo>
+    </x>
+    eoxml
+    assert_nil reader.name
+    assert_equal(["x", "#text", "edi:foo", "#text", "edi:foo", "#text", "x"],
+                 reader.map { |n| n.name })
+  end
+
+  def test_read_from_memory
+    called = false
+    reader = Nokogiri::XML::Reader.from_memory('<foo>bar</foo>')
+    reader.each do |node|
+      called = true
+      assert node
+    end
+    assert called
+  end
+
+  def test_large_document_smoke_test
+    #  simply run on a large document to verify that there no GC issues
+    xml = []
+    xml << "<elements>"
+    10000.times { |j| xml << "<element id=\"#{j}\"/>" }
+    xml << "</elements>"
+    xml = xml.join("\n")
+
+    Nokogiri::XML::Reader.from_memory(xml).each do |e|
+      e.attributes
+    end
+  end
+
+end