nokogiri 1.8.5 → 1.13.6

data/test/xml/test_reader_encoding.rb

@@ -1,134 +0,0 @@
-# -*- coding: utf-8 -*-
-require "helper"
-
-module Nokogiri
-  module XML
-    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?
-        stress_memory_while do
-          while node = @reader.read
-            nodes = node.send(:attr_nodes)
-            nodes.first.name if nodes.first
-          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,142 +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_invalid_schema_do_not_raise_exceptions
-        xsd = Nokogiri::XML::Schema.new <<EOF
-<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
-	<xs:group name="foo1">
-		<xs:sequence>
-			<xs:element name="bar" type="xs:boolean" />
-		</xs:sequence>
-  </xs:group>
-	<xs:group name="foo2">
-		<xs:sequence>
-			<xs:element name="bar" type="xs:string" />
-		</xs:sequence>
-  </xs:group>
-	<xs:element name="foo">
-		<xs:complexType>
-			<xs:choice>
-				<xs:group ref="foo1"/>
-				<xs:group ref="foo2"/>
-			</xs:choice>
-		</xs:complexType>
-	</xs:element>
-</xs:schema>
-EOF
-        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
-        doc = Nokogiri::XML File.read(PO_XML_FILE)
-        doc.css("city").unlink
-
-        assert errors = @xsd.validate(doc)
-        assert_equal 2, errors.length
-      end
-
-      def test_validate_invalid_file
-        tempfile = Tempfile.new("xml")
-
-        doc = Nokogiri::XML File.read(PO_XML_FILE)
-        doc.css("city").unlink
-        tempfile.write doc.to_xml
-        tempfile.close
-
-        assert errors = @xsd.validate(tempfile.path)
-        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,36 +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
-
-      def test_line_column_level_libxml
-        skip unless Nokogiri.uses_libxml?
-
-        bad_doc = Nokogiri::XML('test')
-        error = bad_doc.errors.first
-
-        assert_equal "1:1: FATAL: Start tag expected, '<' not found", error.message
-        assert_equal 1, error.line
-        assert_equal 1, error.column
-        assert_equal 3, error.level
-      end
-
-      def test_line_column_level_jruby
-        skip unless Nokogiri.jruby?
-
-        bad_doc = Nokogiri::XML('<root>test</bar>')
-        error = bad_doc.errors.first
-
-        assert_equal "The element type \"root\" must be terminated by the matching end-tag \"</root>\".", error.message
-        assert_nil error.line
-        assert_nil error.column
-        assert_nil error.level
-      end
-    end
-  end
-end

data/test/xml/test_text.rb

@@ -1,60 +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
-
-      def test_add_child
-        node = Text.new('foo', Document.new)
-        if Nokogiri.jruby?
-          exc = RuntimeError
-        else
-          exc = ArgumentError
-        end
-        assert_raises(exc) {
-          node.add_child Text.new('bar', Document.new)
-        }
-        assert_raises(exc) {
-          node << Text.new('bar', Document.new)
-        }
-      end
-    end
-  end
-end