nokogiri 1.6.0 → 1.13.2

data/test/xml/test_parse_options.rb

@@ -1,64 +0,0 @@
-require "helper"
-
-module Nokogiri
-  module XML
-    class TestParseOptions < Nokogiri::TestCase
-      def test_new
-        options = Nokogiri::XML::ParseOptions.new
-        assert_equal 0, options.options
-      end
-
-      def test_to_i
-        options = Nokogiri::XML::ParseOptions.new
-        assert_equal 0, options.to_i
-      end
-
-      ParseOptions.constants.each do |constant|
-        next if constant == 'STRICT'
-        class_eval %{
-          def test_predicate_#{constant.downcase}
-            options = ParseOptions.new(ParseOptions::#{constant})
-            assert options.#{constant.downcase}?
-
-            assert ParseOptions.new.#{constant.downcase}.#{constant.downcase}?
-          end
-        }
-      end
-
-      def test_strict_noent
-        options = ParseOptions.new.recover.noent
-        assert !options.strict?
-      end
-
-      def test_new_with_argument
-        options = Nokogiri::XML::ParseOptions.new 1 << 1
-        assert_equal 1 << 1, options.options
-      end
-
-      def test_unsetting
-        options = Nokogiri::XML::ParseOptions.new Nokogiri::XML::ParseOptions::DEFAULT_HTML
-        assert options.nonet?
-        assert options.recover?
-        options.nononet.norecover
-        assert ! options.nonet?
-        assert ! options.recover?
-        options.nonet.recover
-        assert options.nonet?
-        assert options.recover?
-      end
-
-      def test_chaining
-        options = Nokogiri::XML::ParseOptions.new.recover.noent
-        assert options.recover?
-        assert options.noent?
-      end
-
-      def test_inspect
-        options = Nokogiri::XML::ParseOptions.new.recover.noent
-        ins = options.inspect
-        assert_match(/recover/, ins)
-        assert_match(/noent/, ins)
-      end
-    end
-  end
-end

data/test/xml/test_processing_instruction.rb

@@ -1,30 +0,0 @@
-require "helper"
-
-module Nokogiri
-  module XML
-    class TestProcessingInstruction < Nokogiri::TestCase
-      def setup
-        super
-        @xml = Nokogiri::XML.parse(File.read(XML_FILE), XML_FILE)
-      end
-
-      def test_type
-        assert_equal(Node::PI_NODE, @xml.children[0].type)
-      end
-
-      def test_name
-        assert_equal 'TEST-STYLE', @xml.children[0].name
-      end
-
-      def test_new
-        assert ref = ProcessingInstruction.new(@xml, 'name', 'content')
-        assert_instance_of ProcessingInstruction, ref
-      end
-
-      def test_many_new
-        100.times { ProcessingInstruction.new(@xml, 'foo', 'bar') }
-        @xml.root << ProcessingInstruction.new(@xml, 'foo', 'bar')
-      end
-    end
-  end
-end

data/test/xml/test_reader_encoding.rb

@@ -1,142 +0,0 @@
-# -*- coding: utf-8 -*-
-require "helper"
-
-module Nokogiri
-  module XML
-    if RUBY_VERSION =~ /^1\.9/
-      class TestReaderEncoding < Nokogiri::TestCase
-        def setup
-          super
-          @reader = Nokogiri::XML::Reader(
-            File.read(XML_FILE),
-            XML_FILE,
-            'UTF-8'
-          )
-        end
-
-        def test_attribute_at
-          @reader.each do |node|
-            next unless attribute = node.attribute_at(0)
-            assert_equal @reader.encoding, attribute.encoding.name
-          end
-        end
-
-        def test_attributes
-          @reader.each do |node|
-            node.attributes.each do |k,v|
-              assert_equal @reader.encoding, k.encoding.name
-              assert_equal @reader.encoding, v.encoding.name
-            end
-          end
-        end
-
-        def test_attribute
-          xml = <<-eoxml
-    <x xmlns:tenderlove='http://tenderlovemaking.com/'>
-      <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
-    </x>
-          eoxml
-          reader = Nokogiri::XML::Reader(xml, nil, 'UTF-8')
-          reader.each do |node|
-            next unless attribute = node.attribute('awesome')
-            assert_equal reader.encoding, attribute.encoding.name
-          end
-        end
-
-        def test_xml_version
-          @reader.each do |node|
-            next unless version = node.xml_version
-            assert_equal @reader.encoding, version.encoding.name
-          end
-        end
-
-        def test_lang
-          xml = <<-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(xml, nil, 'UTF-8')
-          reader.each do |node|
-            next unless lang = node.lang
-            assert_equal reader.encoding, lang.encoding.name
-          end
-        end
-
-        def test_value
-          called = false
-          @reader.each do |node|
-            next unless value = node.value
-            assert_equal @reader.encoding, value.encoding.name
-            called = true
-          end
-          assert called
-        end
-
-        def test_prefix
-          xml = <<-eoxml
-    <x xmlns:edi='http://ecommerce.example.org/schema'>
-      <edi:foo>hello</edi:foo>
-    </x>
-          eoxml
-          reader = Nokogiri::XML::Reader(xml, nil, 'UTF-8')
-          reader.each do |node|
-            next unless prefix = node.prefix
-            assert_equal reader.encoding, prefix.encoding.name
-          end
-        end
-
-        def test_ns_uri
-          xml = <<-eoxml
-    <x xmlns:edi='http://ecommerce.example.org/schema'>
-      <edi:foo>hello</edi:foo>
-    </x>
-          eoxml
-          reader = Nokogiri::XML::Reader(xml, nil, 'UTF-8')
-          reader.each do |node|
-            next unless uri = node.namespace_uri
-            assert_equal reader.encoding, uri.encoding.name
-          end
-        end
-
-        def test_local_name
-          xml = <<-eoxml
-    <x xmlns:edi='http://ecommerce.example.org/schema'>
-      <edi:foo>hello</edi:foo>
-    </x>
-          eoxml
-          reader = Nokogiri::XML::Reader(xml, nil, 'UTF-8')
-          reader.each do |node|
-            next unless lname = node.local_name
-            assert_equal reader.encoding, lname.encoding.name
-          end
-        end
-
-        def test_name
-          @reader.each do |node|
-            next unless name = node.name
-            assert_equal @reader.encoding, name.encoding.name
-          end
-        end
-
-        def test_value_lookup_segfault
-          skip("JRuby doesn't do GC.") if Nokogiri.jruby?
-          old_stress = GC.stress
-
-          begin
-            GC.stress = true
-
-            while node = @reader.read
-              nodes = node.send(:attr_nodes)
-              nodes.first.name if nodes.first
-            end
-          ensure
-            GC.stress = old_stress
-          end
-        end
-      end
-    end
-  end
-end

data/test/xml/test_relax_ng.rb

@@ -1,60 +0,0 @@
-require "helper"
-
-module Nokogiri
-  module XML
-    class TestRelaxNG < Nokogiri::TestCase
-      def setup
-        assert @schema = Nokogiri::XML::RelaxNG(File.read(ADDRESS_SCHEMA_FILE))
-      end
-
-      def test_parse_with_memory
-        assert_instance_of Nokogiri::XML::RelaxNG, @schema
-        assert_equal 0, @schema.errors.length
-      end
-
-      def test_new
-        assert schema = Nokogiri::XML::RelaxNG.new(
-          File.read(ADDRESS_SCHEMA_FILE))
-        assert_instance_of Nokogiri::XML::RelaxNG, schema
-      end
-
-      def test_parse_with_io
-        xsd = nil
-        File.open(ADDRESS_SCHEMA_FILE, 'rb') { |f|
-          assert xsd = Nokogiri::XML::RelaxNG(f)
-        }
-        assert_equal 0, xsd.errors.length
-      end
-
-      def test_parse_with_errors
-        xml = File.read(ADDRESS_SCHEMA_FILE).sub(/name="/, 'name=')
-        assert_raises(Nokogiri::XML::SyntaxError) {
-          Nokogiri::XML::RelaxNG(xml)
-        }
-      end
-
-      def test_validate_document
-        doc = Nokogiri::XML(File.read(ADDRESS_XML_FILE))
-        assert errors = @schema.validate(doc)
-        assert_equal 0, errors.length
-      end
-
-      def test_validate_invalid_document
-        # Empty address book is not allowed
-        read_doc = '<addressBook></addressBook>'
-
-        assert errors = @schema.validate(Nokogiri::XML(read_doc))
-        assert_equal 1, errors.length
-      end
-
-      def test_valid?
-        valid_doc = Nokogiri::XML(File.read(ADDRESS_XML_FILE))
-
-        invalid_doc = Nokogiri::XML('<addressBook></addressBook>')
-
-        assert(@schema.valid?(valid_doc))
-        assert(!@schema.valid?(invalid_doc))
-      end
-    end
-  end
-end

data/test/xml/test_schema.rb

@@ -1,103 +0,0 @@
-require "helper"
-
-module Nokogiri
-  module XML
-    class TestSchema < Nokogiri::TestCase
-      def setup
-        assert @xsd = Nokogiri::XML::Schema(File.read(PO_SCHEMA_FILE))
-      end
-
-      def test_schema_from_document
-        doc = Nokogiri::XML(File.open(PO_SCHEMA_FILE))
-        assert doc
-        xsd = Nokogiri::XML::Schema.from_document doc
-        assert_instance_of Nokogiri::XML::Schema, xsd
-      end
-
-      def test_schema_from_document_node
-        doc = Nokogiri::XML(File.open(PO_SCHEMA_FILE))
-        assert doc
-        xsd = Nokogiri::XML::Schema.from_document doc.root
-        assert_instance_of Nokogiri::XML::Schema, xsd
-      end
-
-      def test_schema_validates_with_relative_paths
-        xsd = File.join(ASSETS_DIR, 'foo', 'foo.xsd')
-        xml = File.join(ASSETS_DIR, 'valid_bar.xml')
-        doc = Nokogiri::XML(File.open(xsd))
-        xsd = Nokogiri::XML::Schema.from_document doc
-
-        doc = Nokogiri::XML(File.open(xml))
-        assert xsd.valid?(doc)
-      end
-
-      def test_parse_with_memory
-        assert_instance_of Nokogiri::XML::Schema, @xsd
-        assert_equal 0, @xsd.errors.length
-      end
-
-      def test_new
-        assert xsd = Nokogiri::XML::Schema.new(File.read(PO_SCHEMA_FILE))
-        assert_instance_of Nokogiri::XML::Schema, xsd
-      end
-
-      def test_parse_with_io
-        xsd = nil
-        File.open(PO_SCHEMA_FILE, 'rb') { |f|
-          assert xsd = Nokogiri::XML::Schema(f)
-        }
-        assert_equal 0, xsd.errors.length
-      end
-
-      def test_parse_with_errors
-        xml = File.read(PO_SCHEMA_FILE).sub(/name="/, 'name=')
-        assert_raises(Nokogiri::XML::SyntaxError) {
-          Nokogiri::XML::Schema(xml)
-        }
-      end
-
-      def test_validate_document
-        doc = Nokogiri::XML(File.read(PO_XML_FILE))
-        assert errors = @xsd.validate(doc)
-        assert_equal 0, errors.length
-      end
-
-      def test_validate_file
-        assert errors = @xsd.validate(PO_XML_FILE)
-        assert_equal 0, errors.length
-      end
-
-      def test_validate_invalid_document
-        read_doc = File.read(PO_XML_FILE).gsub(/<city>[^<]*<\/city>/, '')
-
-        assert errors = @xsd.validate(Nokogiri::XML(read_doc))
-        assert_equal 2, errors.length
-      end
-
-      def test_validate_non_document
-        string = File.read(PO_XML_FILE)
-        assert_raise(ArgumentError) {@xsd.validate(string)}
-      end
-
-      def test_valid?
-        valid_doc = Nokogiri::XML(File.read(PO_XML_FILE))
-
-        invalid_doc = Nokogiri::XML(
-          File.read(PO_XML_FILE).gsub(/<city>[^<]*<\/city>/, '')
-        )
-
-        assert(@xsd.valid?(valid_doc))
-        assert(!@xsd.valid?(invalid_doc))
-      end
-
-      def test_xsd_with_dtd
-        Dir.chdir(File.join(ASSETS_DIR, 'saml')) do
-           # works
-           Nokogiri::XML::Schema(IO.read('xmldsig_schema.xsd'))
-           # was not working
-           Nokogiri::XML::Schema(IO.read('saml20protocol_schema.xsd'))
-        end
-      end
-    end
-  end
-end

data/test/xml/test_syntax_error.rb

@@ -1,12 +0,0 @@
-require "helper"
-
-module Nokogiri
-  module XML
-    class TestSyntaxError < Nokogiri::TestCase
-      def test_new
-        error = Nokogiri::XML::SyntaxError.new 'hello'
-        assert_equal 'hello', error.message
-      end
-    end
-  end
-end

data/test/xml/test_text.rb

@@ -1,45 +0,0 @@
-require "helper"
-
-module Nokogiri
-  module XML
-    class TestText < Nokogiri::TestCase
-      def test_css_path
-        doc  = Nokogiri.XML "<root> foo <a>something</a> bar bazz </root>"
-        node = doc.root.children[2]
-        assert_instance_of Nokogiri::XML::Text, node
-        assert_equal node, doc.at_css(node.css_path)
-      end
-
-      def test_inspect
-        node = Text.new('hello world', Document.new)
-        assert_equal "#<#{node.class.name}:#{sprintf("0x%x",node.object_id)} #{node.text.inspect}>", node.inspect
-      end
-
-      def test_new
-        node = Text.new('hello world', Document.new)
-        assert node
-        assert_equal('hello world', node.content)
-        assert_instance_of Nokogiri::XML::Text, node
-      end
-
-      def test_lots_of_text
-        100.times { Text.new('hello world', Document.new) }
-      end
-
-      def test_new_without_document
-        doc = Document.new
-        node = Nokogiri::XML::Element.new('foo', doc)
-
-        assert Text.new('hello world', node)
-      end
-
-      def test_content=
-        node = Text.new('foo', Document.new)
-        assert_equal('foo', node.content)
-        node.content = '& <foo> &amp;'
-        assert_equal('& <foo> &amp;', node.content)
-        assert_equal('&amp; &lt;foo&gt; &amp;amp;', node.to_xml)
-      end
-    end
-  end
-end