gss 0.0.5

data/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.6.2.1-x86-mingw32/test/xml/test_parse_options.rb

@@ -0,0 +1,64 @@
+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/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.6.2.1-x86-mingw32/test/xml/test_processing_instruction.rb

@@ -0,0 +1,30 @@
+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/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.6.2.1-x86-mingw32/test/xml/test_reader_encoding.rb

@@ -0,0 +1,142 @@
+# -*- 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/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.6.2.1-x86-mingw32/test/xml/test_relax_ng.rb

@@ -0,0 +1,60 @@
+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/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.6.2.1-x86-mingw32/test/xml/test_schema.rb

@@ -0,0 +1,129 @@
+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
+        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/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.6.2.1-x86-mingw32/test/xml/test_syntax_error.rb

@@ -0,0 +1,12 @@
+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/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.6.2.1-x86-mingw32/test/xml/test_text.rb

@@ -0,0 +1,60 @@
+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