search_biomodel 1.0.0 → 1.0.1

data/search_biomodel/ruby/1.8/gems/nokogiri-1.4.6/test/test_reader.rb

@@ -1,421 +0,0 @@
-# -*- coding: utf-8 -*-
-require "helper"
-
-class TestReader < Nokogiri::TestCase
-  def test_from_io_sets_io_as_source
-    io = File.open SNUGGLES_FILE
-    reader = Nokogiri::XML::Reader.from_io(io)
-    assert_equal io, reader.source
-  end
-
-  def test_empty_element?
-    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-<xml><city>Paris</city><state/></xml>
-    eoxml
-
-    results = reader.map do |node|
-      if node.node_type == Nokogiri::XML::Node::ELEMENT_NODE
-        node.empty_element?
-      end
-    end
-    assert_equal [false, false, nil, nil, true, nil], results
-  end
-
-  def test_self_closing?
-    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-<xml><city>Paris</city><state/></xml>
-    eoxml
-
-    results = reader.map do |node|
-      if node.node_type == Nokogiri::XML::Node::ELEMENT_NODE
-        node.self_closing?
-      end
-    end
-    assert_equal [false, false, nil, nil, true, nil], results
-  end
-
-  def test_reader_takes_block
-    options = nil
-    Nokogiri::XML::Reader(File.read(XML_FILE), XML_FILE) do |cfg|
-      options = cfg
-      options.nonet.nowarning.dtdattr
-    end
-    assert options.nonet?
-    assert options.nowarning?
-    assert options.dtdattr?
-  end
-
-  def test_nil_raises
-    assert_raises(ArgumentError) {
-      Nokogiri::XML::Reader.from_memory(nil)
-    }
-    assert_raises(ArgumentError) {
-      Nokogiri::XML::Reader.from_io(nil)
-    }
-  end
-
-  def test_from_io
-    io = File.open SNUGGLES_FILE
-    reader = Nokogiri::XML::Reader.from_io(io)
-    assert_equal false, reader.default?
-    assert_equal [false, false, false, false, false, false, false],
-      reader.map { |x| x.default? }
-  end
-
-  def test_io
-    io = File.open SNUGGLES_FILE
-    reader = Nokogiri::XML::Reader(io)
-    assert_equal false, reader.default?
-    assert_equal [false, false, false, false, false, false, false],
-      reader.map { |x| x.default? }
-  end
-
-  def test_string_io
-    io = StringIO.new(<<-eoxml)
-    <x xmlns:tenderlove='http://tenderlovemaking.com/'>
-      <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
-    </x>
-    eoxml
-    reader = Nokogiri::XML::Reader(io)
-    assert_equal false, reader.default?
-    assert_equal [false, false, false, false, false, false, false],
-      reader.map { |x| x.default? }
-  end
-  
-  class ReallyBadIO
-    def read(size)
-      'a' * size ** 10
-    end
-  end
-
-  unless Nokogiri.ffi?
-    def test_io_that_reads_too_much
-      io = ReallyBadIO.new
-      Nokogiri::XML::Reader(io)
-    end
-  end
-
-  def test_in_memory
-    assert Nokogiri::XML::Reader(<<-eoxml)
-    <x xmlns:tenderlove='http://tenderlovemaking.com/'>
-      <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
-    </x>
-    eoxml
-  end
-
-  def test_reader_holds_on_to_string
-    xml = <<-eoxml
-    <x xmlns:tenderlove='http://tenderlovemaking.com/'>
-      <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
-    </x>
-    eoxml
-    reader = Nokogiri::XML::Reader(xml)
-    if Nokogiri.ffi?
-      assert_not_nil reader.source
-      assert reader.source.is_a?(FFI::MemoryPointer)
-    else
-      assert_equal xml, reader.source
-    end
-  end
-
-  def test_default?
-    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-    <x xmlns:tenderlove='http://tenderlovemaking.com/'>
-      <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
-    </x>
-    eoxml
-    assert_equal false, reader.default?
-    assert_equal [false, false, false, false, false, false, false],
-      reader.map { |x| x.default? }
-  end
-
-  def test_value?
-    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-    <x xmlns:tenderlove='http://tenderlovemaking.com/'>
-      <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
-    </x>
-    eoxml
-    assert_equal false, reader.value?
-    assert_equal [false, true, false, true, false, true, false],
-      reader.map { |x| x.value? }
-  end
-
-  def test_read_error_document
-    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-    <x xmlns:tenderlove='http://tenderlovemaking.com/'>
-      <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
-      <foo>
-    </x>
-    eoxml
-    assert_raises(Nokogiri::XML::SyntaxError) do
-      reader.each { |node| }
-    end
-    assert 1, reader.errors.length
-  end
-
-  def test_attributes?
-    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-    <x xmlns:tenderlove='http://tenderlovemaking.com/'>
-      <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
-    </x>
-    eoxml
-    assert_equal false, reader.attributes?
-    assert_equal [true, false, true, false, true, false, true],
-      reader.map { |x| x.attributes? }
-  end
-
-  def test_attributes
-    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-    <x xmlns:tenderlove='http://tenderlovemaking.com/'
-       xmlns='http://mothership.connection.com/'
-       >
-      <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
-    </x>
-    eoxml
-    assert_equal({}, reader.attributes)
-    assert_equal [{'xmlns:tenderlove'=>'http://tenderlovemaking.com/',
-                   'xmlns'=>'http://mothership.connection.com/'},
-                  {}, {"awesome"=>"true"}, {}, {"awesome"=>"true"}, {},
-                  {'xmlns:tenderlove'=>'http://tenderlovemaking.com/',
-                   'xmlns'=>'http://mothership.connection.com/'}],
-      reader.map { |x| x.attributes }
-  end
-
-  def test_attribute_roundtrip
-    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-    <x xmlns:tenderlove='http://tenderlovemaking.com/'
-       xmlns='http://mothership.connection.com/'
-       >
-      <tenderlove:foo awesome='true' size='giant'>snuggles!</tenderlove:foo>
-    </x>
-    eoxml
-    reader.each do |node|
-      node.attributes.each do |key, value|
-        assert_equal value, node.attribute(key)
-      end
-    end
-  end
-
-  def test_attribute_at
-    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-    <x xmlns:tenderlove='http://tenderlovemaking.com/'>
-      <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
-    </x>
-    eoxml
-    assert_nil reader.attribute_at(nil)
-    assert_nil reader.attribute_at(0)
-    assert_equal ['http://tenderlovemaking.com/', nil, 'true', nil, 'true', nil, 'http://tenderlovemaking.com/'],
-      reader.map { |x| x.attribute_at(0) }
-  end
-
-  def test_attribute
-    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-    <x xmlns:tenderlove='http://tenderlovemaking.com/'>
-      <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
-    </x>
-    eoxml
-    assert_nil reader.attribute(nil)
-    assert_nil reader.attribute('awesome')
-    assert_equal [nil, nil, 'true', nil, 'true', nil, nil],
-      reader.map { |x| x.attribute('awesome') }
-  end
-
-  def test_attribute_length
-    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-    <x xmlns:tenderlove='http://tenderlovemaking.com/'>
-      <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
-    </x>
-    eoxml
-    assert_equal 0, reader.attribute_count
-    assert_equal [1, 0, 1, 0, 0, 0, 0], reader.map { |x| x.attribute_count }
-  end
-
-  def test_depth
-    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-    <x xmlns:tenderlove='http://tenderlovemaking.com/'>
-      <tenderlove:foo>snuggles!</tenderlove:foo>
-    </x>
-    eoxml
-    assert_equal 0, reader.depth
-    assert_equal [0, 1, 1, 2, 1, 1, 0], reader.map { |x| x.depth }
-  end
-
-  def test_encoding
-    string = <<-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.from_memory(string, nil, 'UTF-8')
-    assert_equal ['UTF-8'], reader.map { |x| x.encoding }.uniq
-  end
-
-  def test_xml_version
-    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-    <x xmlns:tenderlove='http://tenderlovemaking.com/'>
-      <tenderlove:foo>snuggles!</tenderlove:foo>
-    </x>
-    eoxml
-    assert_nil reader.xml_version
-    assert_equal ['1.0'], reader.map { |x| x.xml_version }.uniq
-  end
-
-  def test_lang
-    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-    <awesome>
-      <p xml:lang="en">The quick brown fox jumps over the lazy dog.</p>
-      <p xml:lang="ja">日本語が上手です</p>
-    </awesome>
-    eoxml
-    assert_nil reader.lang
-    assert_equal [nil, nil, "en", "en", "en", nil, "ja", "ja", "ja", nil, nil],
-      reader.map { |x| x.lang }
-  end
-
-  def test_value
-    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-    <x xmlns:tenderlove='http://tenderlovemaking.com/'>
-      <tenderlove:foo>snuggles!</tenderlove:foo>
-    </x>
-    eoxml
-    assert_nil reader.value
-    assert_equal [nil, "\n      ", nil, "snuggles!", nil, "\n    ", nil],
-      reader.map { |x| x.value }
-  end
-
-  def test_prefix
-    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-    <x xmlns:edi='http://ecommerce.example.org/schema'>
-      <edi:foo>hello</edi:foo>
-    </x>
-    eoxml
-    assert_nil reader.prefix
-    assert_equal [nil, nil, "edi", nil, "edi", nil, nil],
-      reader.map { |n| n.prefix }
-  end
-
-  def test_node_type
-    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-    <x>
-      <y>hello</y>
-    </x>
-    eoxml
-    assert_equal 0, reader.node_type
-    assert_equal [1, 14, 1, 3, 15, 14, 15], reader.map { |n| n.node_type }
-  end
-
-  def test_inner_xml
-    str = "<x><y>hello</y></x>"
-    reader = Nokogiri::XML::Reader.from_memory(str)
-
-    reader.read
-
-    assert_equal "<y>hello</y>", reader.inner_xml
-  end
-
-  def test_outer_xml
-    str = "<x><y>hello</y></x>"
-    reader = Nokogiri::XML::Reader.from_memory(str)
-
-    reader.read
-
-    assert_equal str, reader.outer_xml
-  end
-
-  def test_state
-    reader = Nokogiri::XML::Reader.from_memory('<foo>bar</bar>')
-    assert reader.state
-  end
-
-  def test_ns_uri
-    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-    <x xmlns:edi='http://ecommerce.example.org/schema'>
-      <edi:foo>hello</edi:foo>
-    </x>
-    eoxml
-    assert_nil reader.namespace_uri
-    assert_equal([nil,
-                  nil,
-                  "http://ecommerce.example.org/schema",
-                  nil,
-                  "http://ecommerce.example.org/schema",
-                  nil,
-                  nil],
-                  reader.map { |n| n.namespace_uri })
-  end
-
-  def test_local_name
-    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-    <x xmlns:edi='http://ecommerce.example.org/schema'>
-      <edi:foo>hello</edi:foo>
-    </x>
-    eoxml
-    assert_nil reader.local_name
-    assert_equal(["x", "#text", "foo", "#text", "foo", "#text", "x"],
-                 reader.map { |n| n.local_name })
-  end
-
-  def test_name
-    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-    <x xmlns:edi='http://ecommerce.example.org/schema'>
-      <edi:foo>hello</edi:foo>
-    </x>
-    eoxml
-    assert_nil reader.name
-    assert_equal(["x", "#text", "edi:foo", "#text", "edi:foo", "#text", "x"],
-                 reader.map { |n| n.name })
-  end
-
-  def test_base_uri
-    reader = Nokogiri::XML::Reader.from_memory(<<-eoxml)
-      <x xml:base="http://base.example.org/base/">
-        <link href="link"/>
-        <other xml:base="http://other.example.org/"/>
-        <relative xml:base="relative">
-          <link href="stuff" />
-        </relative>
-      </x>
-    eoxml
-
-    assert_nil reader.base_uri
-    assert_equal(["http://base.example.org/base/",
-                  "http://base.example.org/base/",
-                  "http://base.example.org/base/",
-                  "http://base.example.org/base/",
-                  "http://other.example.org/",
-                  "http://base.example.org/base/",
-                  "http://base.example.org/base/relative",
-                  "http://base.example.org/base/relative",
-                  "http://base.example.org/base/relative",
-                  "http://base.example.org/base/relative",
-                  "http://base.example.org/base/relative",
-                  "http://base.example.org/base/",
-                  "http://base.example.org/base/"],
-                  reader.map {|n| n.base_uri })
-  end
-
-  def test_read_from_memory
-    called = false
-    reader = Nokogiri::XML::Reader.from_memory('<foo>bar</foo>')
-    reader.each do |node|
-      called = true
-      assert node
-    end
-    assert called
-  end
-
-  def test_large_document_smoke_test
-    #  simply run on a large document to verify that there no GC issues
-    xml = []
-    xml << "<elements>"
-    10000.times { |j| xml << "<element id=\"#{j}\"/>" }
-    xml << "</elements>"
-    xml = xml.join("\n")
-
-    Nokogiri::XML::Reader.from_memory(xml).each do |e|
-      e.attributes
-    end
-  end
-
-end

data/search_biomodel/ruby/1.8/gems/nokogiri-1.4.6/test/test_soap4r_sax.rb

@@ -1,52 +0,0 @@
-require "helper"
-
-module XSD
-  module XMLParser
-    class Parser
-      @factory_added = nil
-
-      class << self; attr_reader :factory_added; end
-
-      def self.add_factory o
-        @factory_added = o
-      end
-
-      def initialize *args
-        @charset = nil
-      end
-
-      def characters foo
-      end
-
-      def start_element *args
-      end
-
-      def end_element *args
-      end
-    end
-  end
-end
-
-require 'xsd/xmlparser/nokogiri'
-
-class TestSoap4rSax < Nokogiri::TestCase
-  def test_factory_added
-    assert_equal XSD::XMLParser::Nokogiri, XSD::XMLParser::Nokogiri.factory_added
-  end
-
-  def test_parse
-    o = Class.new(::XSD::XMLParser::Nokogiri) do
-      attr_accessor :element_started
-      def initialize *args
-        super
-        @element_started = false
-      end
-
-      def start_element *args
-        @element_started = true
-      end
-    end.new 'foo'
-    o.do_parse '<?xml version="1.0" ?><root xmlns="http://example.com/"/>'
-    assert o.element_started, 'element started'
-  end
-end

data/search_biomodel/ruby/1.8/gems/nokogiri-1.4.6/test/test_xslt_transforms.rb

@@ -1,193 +0,0 @@
-require "helper"
-
-class TestXsltTransforms < Nokogiri::TestCase
-  def setup
-    @doc = Nokogiri::XML(File.open(XML_FILE))
-  end
-
-  if Nokogiri.uses_libxml?
-    def test_class_methods
-      style = Nokogiri::XSLT(File.read(XSLT_FILE))
-
-      assert result = style.apply_to(@doc, ['title', '"Grandma"'])
-      assert_match %r{<h1>Grandma</h1>}, result
-    end
-
-    def test_transform
-      assert style = Nokogiri::XSLT.parse(File.read(XSLT_FILE))
-
-      assert result = style.apply_to(@doc, ['title', '"Booyah"'])
-      assert_match %r{<h1>Booyah</h1>}, result
-      assert_match %r{<th.*Employee ID</th>}, result
-      assert_match %r{<th.*Name</th>}, result
-      assert_match %r{<th.*Position</th>}, result
-      assert_match %r{<th.*Salary</th>}, result
-      assert_match %r{<td>EMP0003</td>}, result
-      assert_match %r{<td>Margaret Martin</td>}, result
-      assert_match %r{<td>Computer Specialist</td>}, result
-      assert_match %r{<td>100,000</td>}, result
-      assert_no_match %r{Dallas|Texas}, result
-      assert_no_match %r{Female}, result
-
-      assert result = style.apply_to(@doc, ['title', '"Grandma"'])
-      assert_match %r{<h1>Grandma</h1>}, result
-
-      assert result = style.apply_to(@doc)
-      assert_match %r{<h1></h1>}, result
-    end
-
-    def test_transform_with_output_style
-      xslt = Nokogiri::XSLT(<<-eoxslt)
-<?xml version="1.0" encoding="ISO-8859-1"?>
-
-<xsl:stylesheet version="1.0"
-xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
-<xsl:output method="text" version="1.0"
-encoding="iso-8859-1" indent="yes"/>
-
-<xsl:param name="title"/>
-
-<xsl:template match="/">
-  <html>
-  <body>
-    <xsl:for-each select="staff/employee">
-    <tr>
-      <td><xsl:value-of select="employeeId"/></td>
-      <td><xsl:value-of select="name"/></td>
-      <td><xsl:value-of select="position"/></td>
-      <td><xsl:value-of select="salary"/></td>
-    </tr>
-    </xsl:for-each>
-    </table>
-  </body>
-  </html>
-</xsl:template>
-
-</xsl:stylesheet>
-      eoxslt
-      assert_no_match(/<td>/, xslt.apply_to(@doc, ['title', 'foo']))
-    end
-
-    def test_transform_arg_error
-      assert style = Nokogiri::XSLT(File.read(XSLT_FILE))
-      assert_raises(TypeError) do
-        style.transform(@doc, :foo)
-      end
-    end
-
-    def test_transform_with_hash
-      assert style = Nokogiri::XSLT(File.read(XSLT_FILE))
-      result = style.transform(@doc, {'title' => '"Booyah"'})
-      assert result.html?
-      assert_equal "Booyah", result.at_css("h1").content
-    end
-
-    def test_transform2
-      assert style = Nokogiri::XSLT(File.open(XSLT_FILE))
-      assert result_doc = style.transform(@doc)
-      assert result_doc.html?
-      assert_equal "", result_doc.at_css("h1").content
-
-      assert style = Nokogiri::XSLT(File.read(XSLT_FILE))
-      assert result_doc = style.transform(@doc, ['title', '"Booyah"'])
-      assert result_doc.html?
-      assert_equal "Booyah", result_doc.at_css("h1").content
-
-      assert result_string = style.apply_to(@doc, ['title', '"Booyah"'])
-      assert_equal result_string, style.serialize(result_doc)
-    end
-
-    def test_transform_with_quote_params
-      assert style = Nokogiri::XSLT(File.open(XSLT_FILE))
-      assert result_doc = style.transform(@doc, Nokogiri::XSLT.quote_params(['title', 'Booyah']))
-      assert result_doc.html?
-      assert_equal "Booyah", result_doc.at_css("h1").content
-
-      assert style = Nokogiri::XSLT.parse(File.read(XSLT_FILE))
-      assert result_doc = style.transform(@doc, Nokogiri::XSLT.quote_params({'title' => 'Booyah'}))
-      assert result_doc.html?
-      assert_equal "Booyah", result_doc.at_css("h1").content
-    end
-
-    def test_quote_params
-      h = {
-        :sym   => %{xxx},
-        'str'  => %{"xxx"},
-        :sym2  => %{'xxx'},
-        'str2' => %{x'x'x},
-        :sym3  => %{x"x"x},
-      }
-      hh=h.dup
-      result_hash = Nokogiri::XSLT.quote_params(h)
-      assert_equal hh, h # non-destructive
-
-      a=h.to_a.flatten
-      result_array = Nokogiri::XSLT.quote_params(a)
-      assert_equal h.to_a.flatten, a #non-destructive
-
-      assert_equal  result_array, result_hash
-    end
-
-    if Nokogiri.uses_libxml? # By now, cannot get it working on JRuby.
-      def test_exslt
-        assert doc = Nokogiri::XML.parse(File.read(EXML_FILE))
-        assert doc.xml?
-
-        assert style = Nokogiri::XSLT.parse(File.read(EXSLT_FILE))
-        params = {
-          :p1 => 'xxx',
-          :p2 => "x'x'x",
-          :p3 => 'x"x"x',
-          :p4 => '"xxx"'
-        }
-        result_doc = Nokogiri::XML.parse(style.apply_to(doc,
-            Nokogiri::XSLT.quote_params(params)))
-
-        assert_equal 'func-result', result_doc.at('/root/function').content
-        assert_equal 3, result_doc.at('/root/max').content.to_i
-        assert_match(
-          /\d{4}-\d\d-\d\d([-|+]\d\d:\d\d)?/,
-          result_doc.at('/root/date').content
-          )
-        result_doc.xpath('/root/params/*').each do  |p|
-          assert_equal p.content, params[p.name.intern]
-        end
-        check_params result_doc, params
-        result_doc = Nokogiri::XML.parse(style.apply_to(doc,
-            Nokogiri::XSLT.quote_params(params.to_a.flatten)))
-        check_params result_doc, params
-      end
-    end
-
-    def test_xslt_parse_error
-      xslt_str = <<-EOX
-<xsl:stylesheet version="1.0"
- xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
-  <!-- Not well-formed: -->
-  <xsl:template match="/"/>
-    <values>
-      <xsl:for-each select="//*">
-        <value>
-          <xsl:value-of select="@id"/>
-        </value>
-      </xsl:for-each>
-    </values>
-  </xsl:template>
-</xsl:stylesheet>}
-      EOX
-      assert_raises(RuntimeError) { Nokogiri::XSLT.parse(xslt_str) }
-    end
-
-    def test_passing_a_non_document_to_transform
-      xsl = Nokogiri::XSLT('<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"></xsl:stylesheet>')
-      assert_raises(ArgumentError) { xsl.transform("<div></div>") }
-      assert_raises(ArgumentError) { xsl.transform(Nokogiri::HTML("").css("body")) }
-    end
-
-    def check_params result_doc, params
-      result_doc.xpath('/root/params/*').each do  |p|
-        assert_equal p.content, params[p.name.intern]
-      end
-    end
-  end
-end

data/search_biomodel/ruby/1.8/gems/nokogiri-1.4.6/test/xml/node/test_save_options.rb

@@ -1,20 +0,0 @@
-require "helper"
-
-module Nokogiri
-  module XML
-    class Node
-      class TestSaveOptions < Nokogiri::TestCase
-        SaveOptions.constants.each do |constant|
-          class_eval %{
-            def test_predicate_#{constant.downcase}
-              options = SaveOptions.new(SaveOptions::#{constant})
-              assert options.#{constant.downcase}?
-
-              assert SaveOptions.new.#{constant.downcase}.#{constant.downcase}?
-            end
-          }
-        end
-      end
-    end
-  end
-end