nokogiri 1.8.5 → 1.13.9

data/test/xml/sax/test_parser_text.rb

@@ -1,202 +0,0 @@
-# -*- coding: utf-8 -*-
-require "helper"
-
-module Nokogiri
-  module XML
-    module SAX
-      class TestParserText < Nokogiri::SAX::TestCase
-        def setup
-          super
-          @doc    = DocWithOrderedItems.new
-          @parser = XML::SAX::Parser.new @doc
-        end
-
-        def test_texts_order
-          xml = <<-eoxml
-<?xml version="1.0" ?>
-<root>
-  text 0
-  <p>
-    text 1
-    <span>text 2</span>
-    text 3
-  </p>
-
-  text 4
-  <!--
-  text 5
-  -->
-
-  <p>
-    <!-- text 6 -->
-    <span><!-- text 7 --></span>
-    <!-- text 8 -->
-  </p>
-
-  <!-- text 9 -->
-  <![CDATA[ text 10 ]]>
-
-  <p>
-    <![CDATA[ text 11 ]]>
-    <span><![CDATA[ text 12 ]]></span>
-    <![CDATA[ text 13 ]]>
-  </p>
-</root>
-          eoxml
-
-          @parser.parse xml
-          items = @doc.items.get_root_content "root"
-          items = items.select_methods [
-            :start_element, :end_element,
-            :characters, :comment, :cdata_block
-          ]
-          items.strip_text! [:characters, :comment, :cdata_block]
-
-          assert_equal [
-            [:characters, 'text 0'],
-
-            [:start_element, 'p', []],
-            [:characters, 'text 1'],
-
-            [:start_element, 'span', []],
-            [:characters, 'text 2'],
-            [:end_element, 'span'],
-
-            [:characters, 'text 3'],
-            [:end_element, 'p'],
-
-            [:characters, 'text 4'],
-            [:comment, 'text 5'],
-            [:characters, ''],
-
-            [:start_element, 'p', []],
-            [:characters, ''],
-            [:comment, 'text 6'],
-            [:characters, ''],
-
-            [:start_element, 'span', []],
-            [:comment, 'text 7'],
-            [:end_element, 'span'],
-            [:characters, ''],
-
-            [:comment, 'text 8'],
-            [:characters, ''],
-            [:end_element, 'p'],
-            [:characters, ''],
-
-            [:comment, 'text 9'],
-            [:characters, ''],
-            [:cdata_block, 'text 10'],
-            [:characters, ''],
-
-            [:start_element, 'p', []],
-            [:characters, ''],
-            [:cdata_block, 'text 11'],
-            [:characters, ''],
-
-            [:start_element, 'span', []],
-            [:cdata_block, 'text 12'],
-            [:end_element, 'span'],
-            [:characters, ''],
-
-            [:cdata_block, 'text 13'],
-            [:characters, ''],
-
-            [:end_element, 'p'],
-            [:characters, '']
-          ], items
-
-          nil
-        end
-
-        def text_whitespace
-          xml = <<-eoxml
-<?xml version="1.0" ?>
-<root>
-  <p>
-    <span></span>
-    <span> </span>
-    <span>
-
-    </span>
-  </p>
-  <p>
-    <!---->
-    <!-- -->
-    <!--
-
-    -->
-  </p>
-  <p>
-    <![CDATA[]]>
-    <![CDATA[ ]]>
-    <![CDATA[
-
-    ]]>
-  </p>
-</root>
-          eoxml
-
-          @parser.parse xml
-          items = @doc.items.get_root_content "root"
-          items = items.select_methods [
-            :start_element, :end_element,
-            :characters, :comment, :cdata_block
-          ]
-          items.strip_text! [:characters, :comment, :cdata_block]
-
-          assert_equal [
-            [:characters, ''],
-            [:start_element, 'p', []],
-
-            [:characters, ''],
-            [:start_element, 'span', []],
-            [:end_element, 'span'],
-            [:characters, ''],
-
-            [:start_element, 'span', []],
-            [:characters, ''],
-            [:end_element, 'span'],
-            [:characters, ''],
-
-            [:start_element, 'span', []],
-            [:characters, ''],
-            [:end_element, 'span'],
-            [:characters, ''],
-
-            [:end_element, 'p'],
-            [:characters, ''],
-
-            [:start_element, 'p', []],
-            [:characters, ''],
-
-            [:comment, ''],
-            [:characters, ''],
-            [:comment, ''],
-            [:characters, ''],
-            [:comment, ''],
-            [:characters, ''],
-
-            [:end_element, 'p'],
-            [:characters, ''],
-
-            [:start_element, 'p', []],
-            [:characters, ''],
-
-            [:cdata_block, ''],
-            [:characters, ''],
-            [:cdata_block, ''],
-            [:characters, ''],
-            [:cdata_block, ''],
-            [:characters, ''],
-
-            [:end_element, 'p'],
-            [:characters, '']
-          ], items
-
-          nil
-        end
-      end
-    end
-  end
-end

data/test/xml/sax/test_push_parser.rb

@@ -1,265 +0,0 @@
-# -*- coding: utf-8 -*-
-
-require "helper"
-
-module Nokogiri
-  module XML
-    module SAX
-      class TestPushParser < Nokogiri::SAX::TestCase
-        def setup
-          super
-          @parser = XML::SAX::PushParser.new(Doc.new)
-        end
-
-        def test_exception
-          assert_raises(SyntaxError) do
-            @parser << "<foo /><foo />"
-          end
-
-          assert_raises(SyntaxError) do
-            @parser << nil
-          end
-        end
-
-        def test_early_finish
-          @parser << "<foo>"
-          assert_raises(SyntaxError) do
-            @parser.finish
-          end
-        end
-
-        def test_write_last_chunk
-          @parser << "<foo>"
-          @parser.write "</foo>", true
-          assert_equal [["foo", []]], @parser.document.start_elements
-          assert_equal [["foo"]], @parser.document.end_elements
-        end
-
-        def test_empty_doc
-          @parser.options |= XML::ParseOptions::RECOVER
-          @parser.write "", true
-          assert_nil @parser.document.start_elements
-          assert_nil @parser.document.end_elements
-        end
-
-
-        def test_finish_should_rethrow_last_error
-          begin
-            @parser << "</foo>"
-          rescue => e
-            expected = e
-          end
-
-          begin
-            @parser.finish
-          rescue => e
-            actual = e
-          end
-
-          assert_equal actual.message, expected.message
-        end
-
-        def test_should_throw_error_returned_by_document
-          doc = Doc.new
-          class << doc
-            def error msg
-              raise "parse error"
-            end
-          end
-
-          @parser = XML::SAX::PushParser.new(doc)
-          begin
-            @parser << "</foo>"
-          rescue => e
-            actual = e
-          end
-
-          assert_equal actual.message, "parse error"
-        end
-
-        def test_writing_nil
-          assert_equal @parser.write(nil), @parser
-        end
-
-        def test_end_document_called
-          @parser.<<(<<-eoxml)
-            <p id="asdfasdf">
-              <!-- This is a comment -->
-              Paragraph 1
-            </p>
-          eoxml
-          assert ! @parser.document.end_document_called
-          @parser.finish
-          assert @parser.document.end_document_called
-        end
-
-        def test_start_element
-          @parser.<<(<<-eoxml)
-            <p id="asdfasdf">
-          eoxml
-
-          assert_equal [["p", [["id", "asdfasdf"]]]],
-            @parser.document.start_elements
-
-          @parser.<<(<<-eoxml)
-              <!-- This is a comment -->
-              Paragraph 1
-            </p>
-          eoxml
-          assert_equal [' This is a comment '], @parser.document.comments
-          @parser.finish
-        end
-
-        def test_start_element_with_namespaces
-          @parser.<<(<<-eoxml)
-            <p xmlns:foo="http://foo.example.com/">
-          eoxml
-
-          assert_equal [["p", [["xmlns:foo", "http://foo.example.com/"]]]],
-            @parser.document.start_elements
-
-          @parser.<<(<<-eoxml)
-              <!-- This is a comment -->
-              Paragraph 1
-            </p>
-          eoxml
-          assert_equal [' This is a comment '], @parser.document.comments
-          @parser.finish
-        end
-
-        def test_start_element_ns
-          @parser.<<(<<-eoxml)
-            <stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams' version='1.0' size='large'></stream:stream>
-          eoxml
-
-          assert_equal 1, @parser.document.start_elements_namespace.length
-          el = @parser.document.start_elements_namespace.first
-
-          assert_equal 'stream', el.first
-          assert_equal 2, el[1].length
-          assert_equal [['version', '1.0'], ['size', 'large']],
-            el[1].map { |x| [x.localname, x.value] }
-
-          assert_equal 'stream', el[2]
-          assert_equal 'http://etherx.jabber.org/streams', el[3]
-          @parser.finish
-        end
-
-        def test_end_element_ns
-          @parser.<<(<<-eoxml)
-            <stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams' version='1.0'></stream:stream>
-          eoxml
-
-          assert_equal [['stream', 'stream', 'http://etherx.jabber.org/streams']],
-            @parser.document.end_elements_namespace
-          @parser.finish
-        end
-
-        def test_chevron_partial_xml
-          @parser.<<(<<-eoxml)
-            <p id="asdfasdf">
-          eoxml
-
-          @parser.<<(<<-eoxml)
-              <!-- This is a comment -->
-              Paragraph 1
-            </p>
-          eoxml
-          assert_equal [' This is a comment '], @parser.document.comments
-          @parser.finish
-        end
-
-        def test_chevron
-          @parser.<<(<<-eoxml)
-            <p id="asdfasdf">
-              <!-- This is a comment -->
-              Paragraph 1
-            </p>
-          eoxml
-          @parser.finish
-          assert_equal [' This is a comment '], @parser.document.comments
-        end
-
-        def test_default_options
-          assert_equal 0, @parser.options
-        end
-
-        def test_recover
-          @parser.options |= XML::ParseOptions::RECOVER
-          @parser.<<(<<-eoxml)
-            <p>
-              Foo
-              <bar>
-              Bar
-            </p>
-          eoxml
-          @parser.finish
-          assert(@parser.document.errors.size >= 1)
-          assert_equal [["p", []], ["bar", []]], @parser.document.start_elements
-          assert_equal "FooBar", @parser.document.data.map { |x|
-            x.gsub(/\s/, '')
-          }.join
-        end
-
-        def test_broken_encoding
-          skip("ultra hard to fix for pure Java version") if Nokogiri.jruby?
-          @parser.options |= XML::ParseOptions::RECOVER
-          # This is ISO_8859-1:
-          @parser.<< "<?xml version='1.0' encoding='UTF-8'?><r>Gau\337</r>"
-          @parser.finish
-          assert(@parser.document.errors.size >= 1)
-          assert_equal "Gau\337", @parser.document.data.join
-          assert_equal [["r"]], @parser.document.end_elements
-        end
-
-        def test_replace_entities_attribute_behavior
-          if Nokogiri.uses_libxml?
-            # initially false
-            assert_equal false, @parser.replace_entities
-
-            # can be set to true
-            @parser.replace_entities = true
-            assert_equal true, @parser.replace_entities
-
-            # can be set to false
-            @parser.replace_entities = false
-            assert_equal false, @parser.replace_entities
-          else
-            # initially true
-            assert_equal true, @parser.replace_entities
-
-            # ignore attempts to set to false
-            @parser.replace_entities = false # TODO: should we raise an exception here?
-            assert_equal true, @parser.replace_entities
-          end
-        end
-
-        def test_untouched_entities
-          skip("entities are always replaced in pure Java version") if Nokogiri.jruby?
-          @parser.<<(<<-eoxml)
-            <p id="asdf&amp;asdf">
-              <!-- This is a comment -->
-              Paragraph 1 &amp; 2
-            </p>
-          eoxml
-          @parser.finish
-          assert_equal [["p", [["id", "asdf&#38;asdf"]]]], @parser.document.start_elements
-          assert_equal "Paragraph 1 & 2", @parser.document.data.join.strip
-        end
-
-        def test_replaced_entities
-          @parser.replace_entities = true
-          @parser.<<(<<-eoxml)
-            <p id="asdf&amp;asdf">
-              <!-- This is a comment -->
-              Paragraph 1 &amp; 2
-            </p>
-          eoxml
-          @parser.finish
-          assert_equal [["p", [["id", "asdf&asdf"]]]], @parser.document.start_elements
-          assert_equal "Paragraph 1 & 2", @parser.document.data.join.strip
-        end
-      end
-    end
-  end
-end

data/test/xml/test_attr.rb

@@ -1,74 +0,0 @@
-require "helper"
-
-module Nokogiri
-  module XML
-    class TestAttr < Nokogiri::TestCase
-      def test_new
-        100.times {
-          doc = Nokogiri::XML::Document.new
-          assert doc
-          assert Nokogiri::XML::Attr.new(doc, 'foo')
-        }
-      end
-
-      def test_new_raises_argerror_on_nondocument
-        document = Nokogiri::XML "<root><foo/></root>"
-        assert_raises ArgumentError do
-          Nokogiri::XML::Attr.new document.at_css("foo"), "bar"
-        end
-      end
-
-      def test_content=
-        xml = Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE)
-        address = xml.xpath('//address')[3]
-        street = address.attributes['street']
-        street.content = "Y&ent1;"
-        assert_equal "Y&ent1;", street.value
-      end
-
-      def test_value=
-        xml = Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE)
-        address = xml.xpath('//address')[3]
-        street = address.attributes['street']
-        street.value = "Y&ent1;"
-        assert_equal "Y&ent1;", street.value
-      end
-
-      def test_unlink # aliased as :remove
-        xml = Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE)
-        address = xml.xpath('/staff/employee/address').first
-        assert_equal 'Yes', address['domestic']
-
-        attr = address.attribute_nodes.first
-        return_val = attr.unlink
-        assert_nil address['domestic']
-        assert_equal attr, return_val
-      end
-
-      def test_parsing_attribute_namespace
-        doc = Nokogiri::XML <<-EOXML
-<root xmlns='http://google.com/' xmlns:f='http://flavorjon.es/'>
-  <div f:myattr='foo'></div>
-</root>
-        EOXML
-
-        node = doc.at_css "div"
-        attr = node.attributes["myattr"]
-        assert_equal "http://flavorjon.es/", attr.namespace.href
-      end
-
-      def test_setting_attribute_namespace
-        doc = Nokogiri::XML <<-EOXML
-<root xmlns='http://google.com/' xmlns:f='http://flavorjon.es/'>
-  <div f:myattr='foo'></div>
-</root>
-        EOXML
-
-        node = doc.at_css "div"
-        attr = node.attributes["myattr"]
-        attr.add_namespace("fizzle", "http://fizzle.com/")
-        assert_equal "http://fizzle.com/", attr.namespace.href
-      end
-    end
-  end
-end

data/test/xml/test_attribute_decl.rb

@@ -1,86 +0,0 @@
-require "helper"
-
-module Nokogiri
-  module XML
-    class TestAttributeDecl < Nokogiri::TestCase
-      def setup
-        super
-        @xml = Nokogiri::XML(<<-eoxml)
-<?xml version="1.0"?><?TEST-STYLE PIDATA?>
-<!DOCTYPE staff SYSTEM "staff.dtd" [
-   <!ATTLIST br width CDATA "0">
-   <!ATTLIST a width CDATA "0">
-   <!ATTLIST payment type (check|cash) "cash">
-]>
-<root />
-        eoxml
-        @attrs = @xml.internal_subset.children
-        @attr_decl = @attrs.first
-      end
-
-      def test_inspect
-        assert_equal(
-          "#<#{@attr_decl.class.name}:#{sprintf("0x%x", @attr_decl.object_id)} #{@attr_decl.to_s.inspect}>",
-          @attr_decl.inspect
-        )
-      end
-
-      def test_type
-        assert_equal 16, @attr_decl.type
-      end
-
-      def test_class
-        assert_instance_of Nokogiri::XML::AttributeDecl, @attr_decl
-      end
-
-      def test_content
-        assert_raise NoMethodError do
-          @attr_decl.content
-        end
-      end
-
-      def test_attributes
-        assert_raise NoMethodError do
-          @attr_decl.attributes
-        end
-      end
-
-      def test_namespace
-        assert_raise NoMethodError do
-          @attr_decl.namespace
-        end
-      end
-
-      def test_namespace_definitions
-        assert_raise NoMethodError do
-          @attr_decl.namespace_definitions
-        end
-      end
-
-      def test_line
-        assert_raise NoMethodError do
-          @attr_decl.line
-        end
-      end
-
-      def test_attribute_type
-        if Nokogiri.uses_libxml?
-          assert_equal 1, @attr_decl.attribute_type
-        else
-          assert_equal 'CDATA', @attr_decl.attribute_type
-        end
-      end
-
-      def test_default
-        assert_equal '0', @attr_decl.default
-        assert_equal '0', @attrs[1].default
-      end
-
-      def test_enumeration
-        assert_equal [], @attr_decl.enumeration
-        assert_equal ['check', 'cash'], @attrs[2].enumeration
-      end
-    end
-  end
-end
-