nokogiri 1.6.7.2-java → 1.6.8-java

data/test/xml/test_node_reparenting.rb

@@ -49,6 +49,15 @@ module Nokogiri
         #   end
         # end
 
+
+        before do
+          @doc  = Nokogiri::XML "<root><a1>First node</a1><a2>Second node</a2><a3>Third <bx />node</a3></root>"
+          @doc2 = @doc.dup
+          @fragment_string = "<b1>foo</b1><b2>bar</b2>"
+          @fragment        = Nokogiri::XML::DocumentFragment.parse @fragment_string
+          @node_set        = Nokogiri::XML("<root><b1>foo</b1><b2>bar</b2></root>").xpath("/root/node()")
+        end
+
         {
           :add_child            => {:target => "/root/a1",        :returns_self => false, :children_tags => %w[text b1 b2]},
           :<<                   => {:target => "/root/a1",        :returns_self => true, :children_tags => %w[text b1 b2]},
@@ -67,15 +76,6 @@ module Nokogiri
           :next=                => {:target => "/root/a1/text()", :returns_self => false, :children_tags => %w[text b1 b2]},
           :after                => {:target => "/root/a1/text()", :returns_self => true,  :children_tags => %w[text b1 b2]}
         }.each do |method, params|
-
-          before do
-            @doc  = Nokogiri::XML "<root><a1>First node</a1><a2>Second node</a2><a3>Third <bx />node</a3></root>"
-            @doc2 = @doc.dup
-            @fragment_string = "<b1>foo</b1><b2>bar</b2>"
-            @fragment        = Nokogiri::XML::DocumentFragment.parse @fragment_string
-            @node_set        = Nokogiri::XML("<root><b1>foo</b1><b2>bar</b2></root>").xpath("/root/node()")
-          end
-
           describe "##{method}" do
             describe "passed a Node" do
               [:current, :another].each do |which|
@@ -215,7 +215,7 @@ module Nokogiri
             end
           end
 
-          describe "given a parent node with a non-default namespace" do
+          describe "given a parent node with a default and non-default namespace" do
             before do
               @doc = Nokogiri::XML(<<-eoxml)
                 <root xmlns="http://tenderlovemaking.com/" xmlns:foo="http://flavorjon.es/">
@@ -223,18 +223,156 @@ module Nokogiri
                   </first>
                 </root>
               eoxml
+              assert @node = @doc.at('//xmlns:first')
+              @child = Nokogiri::XML::Node.new('second', @doc)
             end
 
-            describe "and a child node with a namespace matching the parent's non-default namespace" do
-              it "inserts a node that inherits the matching parent namespace" do
-                assert node = @doc.at('//xmlns:first')
-                child = Nokogiri::XML::Node.new('second', @doc)
+            describe "and a child with a namespace matching the parent's default namespace" do
+              describe "and as the default prefix" do
+                before do
+                  @ns = @child.add_namespace(nil, 'http://tenderlovemaking.com/')
+                  @child.namespace = @ns
+                end
 
-                ns = @doc.root.namespace_definitions.detect { |x| x.prefix == "foo" }
-                child.namespace = ns
+                it "inserts a node that inherits the parent's default namespace" do
+                  @node.add_child(@child)
+                  assert reparented = @doc.at('//bar:second', "bar" => "http://tenderlovemaking.com/")
+                  assert reparented.namespace_definitions.empty?
+                  assert_equal @ns, reparented.namespace
+                  assert_equal(
+                    {
+                      "xmlns"     => "http://tenderlovemaking.com/",
+                      "xmlns:foo" => "http://flavorjon.es/",
+                    },
+                    reparented.namespaces)
+                end
+              end
+
+              describe "but with a different prefix" do
+                before do
+                  @ns = @child.add_namespace("baz", 'http://tenderlovemaking.com/')
+                  @child.namespace = @ns
+                end
 
-                node.add_child(child)
-                assert @doc.at('//foo:second', "foo" => "http://flavorjon.es/")
+                it "inserts a node that uses its own namespace" do
+                  @node.add_child(@child)
+                  assert reparented = @doc.at('//bar:second', "bar" => "http://tenderlovemaking.com/")
+                  assert reparented.namespace_definitions.include?(@ns)
+                  assert_equal @ns, reparented.namespace
+                  assert_equal(
+                    {
+                      "xmlns"     => "http://tenderlovemaking.com/",
+                      "xmlns:foo" => "http://flavorjon.es/",
+                      "xmlns:baz" => "http://tenderlovemaking.com/",
+                    },
+                    reparented.namespaces)
+                end
+              end
+            end
+
+            describe "and a child with a namespace matching the parent's non-default namespace" do
+              describe "set by #namespace=" do
+                before do
+                  @ns = @doc.root.namespace_definitions.detect { |x| x.prefix == "foo" }
+                  @child.namespace = @ns
+                end
+
+                it "inserts a node that inherits the matching parent namespace" do
+                  @node.add_child(@child)
+                  assert reparented = @doc.at('//bar:second', "bar" => "http://flavorjon.es/")
+                  assert reparented.namespace_definitions.empty?
+                  assert_equal @ns, reparented.namespace
+                  assert_equal(
+                    {
+                      "xmlns"     => "http://tenderlovemaking.com/",
+                      "xmlns:foo" => "http://flavorjon.es/",
+                    },
+                    reparented.namespaces)
+                end
+              end
+
+              describe "with the same prefix" do
+                before do
+                  @ns = @child.add_namespace("foo", 'http://flavorjon.es/')
+                  @child.namespace = @ns
+                end
+
+                it "inserts a node that uses the parent's namespace" do
+                  @node.add_child(@child)
+                  assert reparented = @doc.at('//bar:second', "bar" => "http://flavorjon.es/")
+                  assert reparented.namespace_definitions.empty?
+                  assert_equal @ns, reparented.namespace
+                  assert_equal(
+                    {
+                      "xmlns"     => "http://tenderlovemaking.com/",
+                      "xmlns:foo" => "http://flavorjon.es/",
+                    },
+                    reparented.namespaces)
+                end
+              end
+
+              describe "as the default prefix" do
+                before do
+                  @ns = @child.add_namespace(nil, 'http://flavorjon.es/')
+                  @child.namespace = @ns
+                end
+
+                it "inserts a node that keeps its namespace" do
+                  @node.add_child(@child)
+                  assert reparented = @doc.at('//bar:second', "bar" => "http://flavorjon.es/")
+                  assert reparented.namespace_definitions.include?(@ns)
+                  assert_equal @ns, reparented.namespace
+                  assert_equal(
+                    {
+                      "xmlns"     => "http://flavorjon.es/",
+                      "xmlns:foo" => "http://flavorjon.es/",
+                    },
+                    reparented.namespaces)
+                end
+              end
+
+              describe "but with a different prefix" do
+                before do
+                  @ns = @child.add_namespace('baz', 'http://flavorjon.es/')
+                  @child.namespace = @ns
+                end
+
+                it "inserts a node that keeps its namespace" do
+                  @node.add_child(@child)
+                  assert reparented = @doc.at('//bar:second', "bar" => "http://flavorjon.es/")
+                  assert reparented.namespace_definitions.include?(@ns)
+                  assert_equal @ns, reparented.namespace
+                  assert_equal(
+                    {
+                      "xmlns"     =>"http://tenderlovemaking.com/",
+                      "xmlns:foo" =>"http://flavorjon.es/",
+                      "xmlns:baz" =>"http://flavorjon.es/",
+                    },
+                    reparented.namespaces)
+                end
+              end
+            end
+
+            describe "and a child node with a default namespace not matching the parent's default namespace and a namespace matching a parent namespace but with a different prefix" do
+              before do
+                @ns = @child.add_namespace(nil, 'http://example.org/')
+                @child.namespace = @ns
+                @ns2 = @child.add_namespace('baz', 'http://tenderlovemaking.com/')
+              end
+
+              it "inserts a node that keeps its namespace" do
+                @node.add_child(@child)
+                assert reparented = @doc.at('//bar:second', "bar" => "http://example.org/")
+                assert reparented.namespace_definitions.include?(@ns)
+                assert reparented.namespace_definitions.include?(@ns2)
+                assert_equal @ns, reparented.namespace
+                assert_equal(
+                  {
+                    "xmlns"     => "http://example.org/",
+                    "xmlns:foo" => "http://flavorjon.es/",
+                    "xmlns:baz" => "http://tenderlovemaking.com/",
+                  },
+                  reparented.namespaces)
               end
             end
           end
@@ -368,6 +506,43 @@ module Nokogiri
             end
           end
         end
+
+        describe "reparenting into another document" do
+          it "correctly sets default namespace of a reparented node" do
+            # issue described in #391
+            # thanks to Nick Canzoneri @nickcanz for this test case!
+            source_doc = Nokogiri::XML <<-EOX
+<?xml version="1.0" encoding="utf-8"?>
+<Wix xmlns="http://schemas.microsoft.com/wix/2006/wi">
+    <Product>
+        <Package />
+        <Directory Id="TARGETDIR" Name="SourceDir">
+            <Component>
+                <File />
+            </Component>
+        </Directory>
+    </Product>
+</Wix>
+EOX
+
+            dest_doc = Nokogiri::XML <<-EOX
+<?xml version="1.0" encoding="utf-8"?>
+<Wix xmlns='http://schemas.microsoft.com/wix/2006/wi'>
+  <Fragment Id='MSIComponents'>
+      <DirectoryRef Id='InstallDir'>
+      </DirectoryRef>
+  </Fragment>
+</Wix>
+EOX
+
+            stuff = source_doc.at_css("Directory[Id='TARGETDIR']")
+            insert_point = dest_doc.at_css("DirectoryRef[Id='InstallDir']")
+            insert_point.children = stuff.children()
+
+            assert_no_match(/default:/, insert_point.children.to_xml)
+            assert_match(/<Component>/, insert_point.children.to_xml)
+          end
+        end
       end
     end
   end

data/test/xml/test_node_set.rb

@@ -660,7 +660,7 @@ module Nokogiri
         employees = @xml.search("//employee")
         inspected = employees.inspect
 
-        assert_equal "[#{employees.map { |x| x.inspect }.join(', ')}]",
+        assert_equal "[#{employees.map(&:inspect).join(', ')}]",
           inspected
       end
 

data/test/xml/test_reader.rb

@@ -0,0 +1,589 @@
+# -*- coding: utf-8 -*-
+require "helper"
+
+module Nokogiri
+  module XML
+    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_empty_element?
+        reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
+          <xml><city>Paris</city><state/></xml>
+        eoxml
+
+        results = reader.map do |node|
+          if node.node_type == Nokogiri::XML::Node::ELEMENT_NODE
+            node.empty_element?
+          end
+        end
+        assert_equal [false, false, nil, nil, true, nil], results
+      end
+
+      def test_self_closing?
+        reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
+          <xml><city>Paris</city><state/></xml>
+        eoxml
+
+        results = reader.map do |node|
+          if node.node_type == Nokogiri::XML::Node::ELEMENT_NODE
+            node.self_closing?
+          end
+        end
+        assert_equal [false, false, nil, nil, true, nil], results
+      end
+
+      # Issue #831
+      # Make sure that the reader doesn't block reading the entire input
+      def test_reader_blocking
+        rd, wr = IO.pipe()
+        node_out = nil
+        t = Thread.start do
+          reader = Nokogiri::XML::Reader(rd, 'UTF-8')
+          reader.each do |node|
+            node_out = node
+            break
+          end
+          rd.close
+        end
+        sleep(1)              # sleep for one second to make sure the reader will actually block for input
+        begin
+          wr.puts "<foo>"
+          wr.puts "<bar/>" * 10000
+          wr.flush
+        rescue Errno::EPIPE
+        end
+        res = t.join(5)    # wait 5 seconds for the thread to finish
+        wr.close
+        refute_nil node_out, "Didn't read any nodes, exclude the trivial case"
+        refute_nil res, "Reader blocks trying to read the entire stream"
+      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(&: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(&: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(&:default?)
+      end
+
+      class ReallyBadIO
+        def read(size)
+          'a' * size ** 10
+        end
+      end
+
+      class ReallyBadIO4Java
+        def read(size=1)
+          'a' * size ** 10
+        end
+      end
+
+      def test_io_that_reads_too_much
+        if Nokogiri.jruby?
+          io = ReallyBadIO4Java.new
+          Nokogiri::XML::Reader(io)
+        else
+          io = ReallyBadIO.new
+          Nokogiri::XML::Reader(io)
+        end
+      end
+
+      def test_in_memory
+        assert 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)
+        assert_equal xml, reader.source
+      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(&: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(&: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
+        assert_raises(Nokogiri::XML::SyntaxError) do
+          reader.each { |node| }
+        end
+        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(&: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(&: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(&: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(&: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(&: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(&: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(&: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(&: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(&: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(&: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>", "<y>hello</y>", "hello", "<y/>", "<x/>"]
+        reader = Nokogiri::XML::Reader.from_memory(str.first)
+
+        xml = []
+        reader.map { |node| xml << node.outer_xml }
+
+        assert_equal str, xml
+      end
+
+      def test_outer_xml_with_empty_nodes
+        str = ["<x><y/></x>", "<y/>", "<x/>"]
+        reader = Nokogiri::XML::Reader.from_memory(str.first)
+
+        xml = []
+        reader.map { |node| xml << node.outer_xml }
+
+        assert_equal str, 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(&:namespace_uri))
+      end
+
+      def test_namespaced_attributes
+        reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
+        <x xmlns:edi='http://ecommerce.example.org/schema' xmlns:commons="http://rets.org/xsd/RETSCommons">
+          <edi:foo commons:street-number="43">hello</edi:foo>
+          <y edi:name="francis" bacon="87"/>
+        </x>
+        eoxml
+        attr_ns = []
+        while reader.read
+          if reader.node_type == Nokogiri::XML::Node::ELEMENT_NODE
+            reader.attribute_nodes.each {|attr| attr_ns << (attr.namespace.nil? ? nil : attr.namespace.prefix) }
+          end
+        end
+        assert_equal(['commons',
+                      'edi',
+                      nil],
+                     attr_ns)
+      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(&: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(&:name))
+      end
+
+      def test_base_uri
+        reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
+          <x xml:base="http://base.example.org/base/">
+            <link href="link"/>
+            <other xml:base="http://other.example.org/"/>
+            <relative xml:base="relative">
+              <link href="stuff" />
+            </relative>
+          </x>
+        eoxml
+
+        assert_nil reader.base_uri
+        assert_equal(["http://base.example.org/base/",
+                      "http://base.example.org/base/",
+                      "http://base.example.org/base/",
+                      "http://base.example.org/base/",
+                      "http://other.example.org/",
+                      "http://base.example.org/base/",
+                      "http://base.example.org/base/relative",
+                      "http://base.example.org/base/relative",
+                      "http://base.example.org/base/relative",
+                      "http://base.example.org/base/relative",
+                      "http://base.example.org/base/relative",
+                      "http://base.example.org/base/",
+                      "http://base.example.org/base/"],
+                      reader.map(&:base_uri))
+      end
+
+      def test_xlink_href_without_base_uri
+        reader = Nokogiri::XML::Reader(<<-eoxml)
+          <x xmlns:xlink="http://www.w3.org/1999/xlink">
+            <link xlink:href="#other">Link</link>
+            <other id="other">Linked Element</other>
+          </x>
+        eoxml
+
+        reader.each do |node|
+          if node.node_type == Nokogiri::XML::Reader::TYPE_ELEMENT
+            if node.name == 'link'
+              assert_nil node.base_uri
+            end
+          end
+        end
+      end
+
+      def test_xlink_href_with_base_uri
+        reader = Nokogiri::XML::Reader(<<-eoxml)
+          <x xml:base="http://base.example.org/base/"
+             xmlns:xlink="http://www.w3.org/1999/xlink">
+            <link xlink:href="#other">Link</link>
+            <other id="other">Linked Element</other>
+          </x>
+        eoxml
+
+        reader.each do |node|
+          if node.node_type == Nokogiri::XML::Reader::TYPE_ELEMENT
+            assert_equal node.base_uri, "http://base.example.org/base/"
+          end
+        end
+      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
+
+      def test_correct_outer_xml_inclusion
+        xml = Nokogiri::XML::Reader.from_io(StringIO.new(<<-eoxml))
+          <root-element>
+            <children>
+              <child n="1">
+                <field>child-1</field>
+              </child>
+              <child n="2">
+                <field>child-2</field>
+              </child>
+              <child n="3">
+                <field>child-3</field>
+              </child>
+            </children>
+          </root-element>
+        eoxml
+
+        nodelengths = []
+        has_child2 = []
+
+        xml.each do |node|
+          if node.node_type == Nokogiri::XML::Reader::TYPE_ELEMENT and node.name == "child"
+            nodelengths << node.outer_xml.length
+            has_child2 << !!(node.outer_xml =~ /child-2/)
+          end
+        end
+
+        assert_equal(nodelengths[0], nodelengths[1])
+        assert(has_child2[1])
+        assert(!has_child2[0])
+      end
+
+      def test_correct_inner_xml_inclusion
+        xml = Nokogiri::XML::Reader.from_io(StringIO.new(<<-eoxml))
+          <root-element>
+            <children>
+              <child n="1">
+                <field>child-1</field>
+              </child>
+              <child n="2">
+                <field>child-2</field>
+              </child>
+              <child n="3">
+                <field>child-3</field>
+              </child>
+            </children>
+          </root-element>
+        eoxml
+
+        nodelengths = []
+        has_child2 = []
+
+        xml.each do |node|
+          if node.node_type == Nokogiri::XML::Reader::TYPE_ELEMENT and node.name == "child"
+            nodelengths << node.inner_xml.length
+            has_child2 << !!(node.inner_xml =~ /child-2/)
+          end
+        end
+
+        assert_equal(nodelengths[0], nodelengths[1])
+        assert(has_child2[1])
+        assert(!has_child2[0])
+      end
+
+      def test_nonexistent_attribute
+        require 'nokogiri'
+        reader = Nokogiri::XML::Reader("<root xmlns='bob'><el attr='fred' /></root>")
+        reader.read # root
+        reader.read # el
+        assert_equal nil, reader.attribute('other')
+      end
+    end
+  end
+end