nokogiri 1.8.5-java → 1.9.0-java

data/test/xml/sax/test_parser_context.rb

@@ -1,115 +0,0 @@
-# -*- coding: utf-8 -*-
-
-require "helper"
-
-module Nokogiri
-  module XML
-    module SAX
-      class TestParserContext < Nokogiri::SAX::TestCase
-        def setup
-          @xml = '<hello>
-
-world
-<inter>
-    <net>
-    </net>
-</inter>
-
-</hello>'
-        end
-
-        class Counter < Nokogiri::XML::SAX::Document
-          attr_accessor :context, :lines, :columns
-          def initialize
-            @context = nil
-            @lines   = []
-            @columns = []
-          end
-
-          def start_element name, attrs = []
-            @lines << [name, context.line]
-            @columns << [name, context.column]
-          end
-        end
-
-        def test_line_numbers
-          sax_handler = Counter.new
-
-          parser = Nokogiri::XML::SAX::Parser.new(sax_handler)
-          parser.parse(@xml) do |ctx|
-            sax_handler.context = ctx
-          end
-
-          assert_equal [["hello", 1], ["inter", 4], ["net", 5]],
-            sax_handler.lines
-        end
-
-        def test_column_numbers
-          sax_handler = Counter.new
-
-          parser = Nokogiri::XML::SAX::Parser.new(sax_handler)
-          parser.parse(@xml) do |ctx|
-            sax_handler.context = ctx
-          end
-
-          assert_equal [["hello", 7], ["inter", 7], ["net", 9]],
-            sax_handler.columns
-        end
-
-        def test_replace_entities
-          pc = ParserContext.new StringIO.new('<root />'), 'UTF-8'
-          pc.replace_entities = false
-          assert_equal false, pc.replace_entities
-
-          pc.replace_entities = true
-          assert_equal true, pc.replace_entities
-        end
-
-        def test_recovery
-          pc = ParserContext.new StringIO.new('<root />'), 'UTF-8'
-          pc.recovery = false
-          assert_equal false, pc.recovery
-
-          pc.recovery = true
-          assert_equal true, pc.recovery
-        end
-
-        def test_from_io
-          ctx = ParserContext.new StringIO.new('fo'), 'UTF-8'
-          assert ctx
-        end
-
-        def test_from_string
-          assert ParserContext.new 'blah blah'
-        end
-
-        def test_parse_with
-          ctx = ParserContext.new 'blah'
-          assert_raises ArgumentError do
-            ctx.parse_with nil
-          end
-        end
-
-        def test_parse_with_sax_parser
-          xml = "<root />"
-          ctx = ParserContext.new xml
-          parser = Parser.new Doc.new
-          assert_nil ctx.parse_with parser
-        end
-
-        def test_from_file
-          ctx = ParserContext.file XML_FILE
-          parser = Parser.new Doc.new
-          assert_nil ctx.parse_with parser
-        end
-
-        def test_parse_with_returns_nil
-          xml = "<root />"
-          ctx = ParserContext.new xml
-          parser = Parser.new Doc.new
-          assert_nil ctx.parse_with(parser)
-        end
-      end
-    end
-  end
-end

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