nokogiri 1.8.5-java → 1.9.0-java

data/test/files/to_be_xincluded.xml

@@ -1,2 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<included>this snippet is to be included from xinclude.xml</included>

data/test/files/valid_bar.xml

@@ -1,2 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<bar />

data/test/files/xinclude.xml

@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<test xmlns:xi="http://www.w3.org/2001/XInclude">
-    <xi:include href="to_be_xincluded.xml"/>
-</test>

data/test/helper.rb

@@ -1,271 +0,0 @@
-#Process.setrlimit(Process::RLIMIT_CORE, Process::RLIM_INFINITY) unless RUBY_PLATFORM =~ /(java|mswin|mingw)/i
-$VERBOSE = true
-require 'minitest/autorun'
-require 'minitest/pride'
-require 'fileutils'
-require 'tempfile'
-require 'pp'
-
-require 'nokogiri'
-
-if ENV['TEST_NOKOGIRI_WITH_LIBXML_RUBY']
-  #
-  #  if you'd like to test with the libxml-ruby gem loaded, it's
-  #  recommended that you set
-  #
-  #    BUNDLE_GEMFILE=Gemfile-libxml-ruby
-  #
-  #  which will a) bundle that gem, and b) set the appropriate env var to
-  #  trigger this block
-  #
-  require 'libxml'
-  warn "#{__FILE__}:#{__LINE__}: loaded libxml-ruby '#{LibXML::XML::VERSION}'"
-end
-
-warn "#{__FILE__}:#{__LINE__}: version info: #{Nokogiri::VERSION_INFO.inspect}"
-
-module Nokogiri
-  class TestCase < MiniTest::Spec
-    ASSETS_DIR          = File.expand_path File.join(File.dirname(__FILE__), 'files')
-    ADDRESS_SCHEMA_FILE = File.join(ASSETS_DIR, 'address_book.rlx')
-    ADDRESS_XML_FILE    = File.join(ASSETS_DIR, 'address_book.xml')
-    ENCODING_HTML_FILE  = File.join(ASSETS_DIR, 'encoding.html')
-    ENCODING_XHTML_FILE = File.join(ASSETS_DIR, 'encoding.xhtml')
-    EXML_FILE           = File.join(ASSETS_DIR, 'exslt.xml')
-    EXSLT_FILE          = File.join(ASSETS_DIR, 'exslt.xslt')
-    HTML_FILE           = File.join(ASSETS_DIR, 'tlm.html')
-    METACHARSET_FILE    = File.join(ASSETS_DIR, 'metacharset.html')
-    NICH_FILE           = File.join(ASSETS_DIR, '2ch.html')
-    NOENCODING_FILE     = File.join(ASSETS_DIR, 'noencoding.html')
-    PO_SCHEMA_FILE      = File.join(ASSETS_DIR, 'po.xsd')
-    PO_XML_FILE         = File.join(ASSETS_DIR, 'po.xml')
-    SHIFT_JIS_HTML      = File.join(ASSETS_DIR, 'shift_jis.html')
-    SHIFT_JIS_NO_CHARSET= File.join(ASSETS_DIR, 'shift_jis_no_charset.html')
-    SHIFT_JIS_XML       = File.join(ASSETS_DIR, 'shift_jis.xml')
-    SNUGGLES_FILE       = File.join(ASSETS_DIR, 'snuggles.xml')
-    XML_FILE            = File.join(ASSETS_DIR, 'staff.xml')
-    XML_XINCLUDE_FILE   = File.join(ASSETS_DIR, 'xinclude.xml')
-    XML_ATOM_FILE       = File.join(ASSETS_DIR, 'atom.xml')
-    XSLT_FILE           = File.join(ASSETS_DIR, 'staff.xslt')
-    XPATH_FILE          = File.join(ASSETS_DIR, 'slow-xpath.xml')
-
-    def teardown
-      if ENV['NOKOGIRI_GC']
-        STDOUT.putc '!'
-        if RUBY_PLATFORM =~ /java/
-          require 'java'
-          java.lang.System.gc
-        else
-          GC.start
-        end
-      end
-    end
-
-    def stress_memory_while &block
-      # force the test to explicitly declare a skip
-      raise "JRuby doesn't do GC" if Nokogiri.jruby?
-
-      old_stress = GC.stress
-      begin
-        GC.stress = true
-        yield
-      ensure
-        GC.stress = old_stress
-      end
-    end
-
-    def assert_indent amount, doc, message = nil
-      nodes = []
-      doc.traverse do |node|
-        nodes << node if node.text? && node.blank?
-      end
-      assert nodes.length > 0
-      nodes.each do |node|
-        len = node.content.gsub(/[\r\n]/, '').length
-        assert_equal(0, len % amount, message)
-      end
-    end
-
-    def util_decorate(document, decorator_module)
-      document.decorators(XML::Node) << decorator_module
-      document.decorators(XML::NodeSet) << decorator_module
-      document.decorate!
-    end
-
-    #
-    #  Test::Unit backwards compatibility section
-    #
-    alias :assert_no_match      :refute_match
-    alias :assert_not_nil       :refute_nil
-    alias :assert_raise         :assert_raises
-    alias :assert_not_equal     :refute_equal
-
-    def assert_not_send send_ary, m = nil
-      recv, msg, *args = send_ary
-      m = message(m) {
-        "Expected #{mu_pp(recv)}.#{msg}(*#{mu_pp(args)}) to return false" }
-      assert !recv.__send__(msg, *args), m
-    end unless method_defined?(:assert_not_send)
-  end
-
-  module SAX
-    class TestCase < Nokogiri::TestCase
-      class Doc < XML::SAX::Document
-        attr_reader :start_elements, :start_document_called
-        attr_reader :end_elements, :end_document_called
-        attr_reader :data, :comments, :cdata_blocks, :start_elements_namespace
-        attr_reader :errors, :warnings, :end_elements_namespace
-        attr_reader :xmldecls
-        attr_reader :processing_instructions
-
-        def xmldecl version, encoding, standalone
-          @xmldecls = [version, encoding, standalone].compact
-          super
-        end
-
-        def start_document
-          @start_document_called = true
-          super
-        end
-
-        def end_document
-          @end_document_called = true
-          super
-        end
-
-        def error error
-          (@errors ||= []) << error
-          super
-        end
-
-        def warning warning
-          (@warning ||= []) << warning
-          super
-        end
-
-        def start_element *args
-          (@start_elements ||= []) << args
-          super
-        end
-
-        def start_element_namespace *args
-          (@start_elements_namespace ||= []) << args
-          super
-        end
-
-        def end_element *args
-          (@end_elements ||= []) << args
-          super
-        end
-
-        def end_element_namespace *args
-          (@end_elements_namespace ||= []) << args
-          super
-        end
-
-        def characters string
-          @data ||= []
-          @data += [string]
-          super
-        end
-
-        def comment string
-          @comments ||= []
-          @comments += [string]
-          super
-        end
-
-        def cdata_block string
-          @cdata_blocks ||= []
-          @cdata_blocks += [string]
-          super
-        end
-
-        def processing_instruction name, content
-          @processing_instructions ||= []
-          @processing_instructions << [name, content]
-        end
-      end
-
-      # This document will help us to test the strict order of items.
-
-      class DocWithOrderedItems < XML::SAX::Document
-        attr_reader :items
-
-        def initialize
-          # [
-          #   [ :method_1, argument_1, ... ],
-          #   [ :method_2, argument_2, ... ],
-          #   ...
-          # ]
-          @items = Items.new
-        end
-
-        [
-          :xmldecl,
-          :start_document, :end_document,
-          :start_element, :end_element,
-          :start_element_namespace, :end_element_namespace,
-          :characters, :comment, :cdata_block,
-          :processing_instruction,
-          :error, :warning
-        ]
-        .each do |name|
-          define_method name do |*arguments|
-            @items << [name, *arguments]
-            super *arguments
-          end
-        end
-
-        class Items < Array
-          def get_root_content root_name
-            items          = clone
-            is_inside_root = false
-
-            items.select! do |item|
-              method_name  = item[0]
-              element_name = item[1]
-
-              case method_name
-              when :start_element, :start_element_namespace
-                if element_name == root_name
-                  is_inside_root = true
-                  next false
-                end
-
-              when :end_element, :end_element_namespace
-                is_inside_root = false if element_name == root_name and is_inside_root
-              end
-
-              is_inside_root
-            end
-
-            items
-          end
-
-          def select_methods(names)
-            items = clone
-
-            items.select! do |item|
-              name = item[0]
-              names.include? name
-            end
-
-            items
-          end
-
-          def strip_text! method_names
-            each do |item|
-              method_name = item[0]
-              text        = item[1]
-
-              text.strip! if method_names.include? method_name
-            end
-
-            nil
-          end
-        end
-      end
-    end
-  end
-end

data/test/html/sax/test_parser.rb

@@ -1,168 +0,0 @@
-# -*- coding: utf-8 -*-
-require "helper"
-
-module Nokogiri
-  module HTML
-    module SAX
-      class TestParser < Nokogiri::SAX::TestCase
-        def setup
-          super
-          @parser = HTML::SAX::Parser.new(Doc.new)
-        end
-
-        def test_parse_empty_document
-          # This caused a segfault in libxml 2.6.x
-          assert_nil @parser.parse ''
-        end
-
-        def test_parse_empty_file
-          # Make sure empty files don't break stuff
-          empty_file_name =  File.join(ASSETS_DIR, 'bogus.xml')
-          # assert_nothing_raised do
-            @parser.parse_file empty_file_name
-          # end
-        end
-
-        def test_parse_file
-          @parser.parse_file(HTML_FILE)
-
-          # Take a look at the comment in test_parse_document to know
-          # a possible reason to this difference.
-          if Nokogiri.uses_libxml?
-            assert_equal 1111, @parser.document.end_elements.length
-          else
-            assert_equal 1120, @parser.document.end_elements.length
-          end
-        end
-
-        def test_parse_file_nil_argument
-          assert_raises(ArgumentError) {
-            @parser.parse_file(nil)
-          }
-        end
-
-        def test_parse_file_non_existant
-          assert_raise Errno::ENOENT do
-            @parser.parse_file('there_is_no_reasonable_way_this_file_exists')
-          end
-        end
-
-        def test_parse_file_with_dir
-          assert_raise Errno::EISDIR do
-            @parser.parse_file(File.dirname(__FILE__))
-          end
-        end
-
-        def test_parse_memory_nil
-          assert_raise ArgumentError do
-            @parser.parse_memory(nil)
-          end
-        end
-
-        def test_parse_force_encoding
-          @parser.parse_memory(<<-HTML, 'UTF-8')
-          <meta http-equiv="Content-Type" content="text/html; charset=windows-1251">
-          Информация
-          HTML
-          assert_equal("Информация",
-                       @parser.document.data.join.strip)
-        end
-
-        def test_parse_document
-          @parser.parse_memory(<<-eoxml)
-            <p>Paragraph 1</p>
-            <p>Paragraph 2</p>
-          eoxml
-
-          # JRuby version is different because of the internal implementation
-          # JRuby version uses NekoHTML which inserts empty "head" elements.
-          #
-          # Currently following features are set:
-          # "http://cyberneko.org/html/properties/names/elems" => "lower"
-          # "http://cyberneko.org/html/properties/names/attrs" => "lower"
-          if Nokogiri.uses_libxml?
-            assert_equal([["html", []], ["body", []], ["p", []], ["p", []]],
-                         @parser.document.start_elements)
-          else
-            assert_equal([["html", []], ["head", []], ["body", []], ["p", []], ["p", []]],
-                         @parser.document.start_elements)
-          end
-        end
-
-        def test_parser_attributes
-          html = <<-eohtml
-<html>
-  <head>
-    <title>hello</title>
-  </head>
-<body>
-  <img src="face.jpg" title="daddy &amp; me">
-  <hr noshade size="2">
-</body>
-</html>
-          eohtml
-
-          block_called = false
-          @parser.parse(html) { |ctx|
-            block_called = true
-            ctx.replace_entities = true
-          }
-
-          assert block_called
-
-          noshade_value = if Nokogiri.uses_libxml? && Nokogiri::VERSION_INFO['libxml']['loaded'] < '2.7.7'
-                            ['noshade', 'noshade']
-                          else
-                            ['noshade', nil]
-                          end
-
-          assert_equal [
-            ['html', []],
-            ['head', []],
-            ['title', []],
-            ['body', []],
-            ['img', [
-                ['src', 'face.jpg'],
-                ['title', 'daddy & me']
-              ]],
-            ['hr', [
-                noshade_value,
-                ['size', '2']
-              ]]
-          ], @parser.document.start_elements
-        end
-
-        HTML_WITH_BR_TAG = <<-EOF
-        <html>
-          <head></head>
-          <body>
-            <div>
-              hello
-              <br>
-            </div>
-
-            <div>
-              hello again
-            </div>
-          </body>
-        </html>
-        EOF
-
-        def test_parsing_dom_error_from_string
-          @parser.parse(HTML_WITH_BR_TAG)
-          assert_equal 6, @parser.document.start_elements.length
-        end
-
-        def test_parsing_dom_error_from_io
-          @parser.parse(StringIO.new(HTML_WITH_BR_TAG))
-          assert_equal 6, @parser.document.start_elements.length
-        end
-
-
-        def test_empty_processing_instruction
-          @parser.parse_memory("<strong>this will segfault<?strong>")
-        end
-      end
-    end
-  end
-end