search_biomodel 1.0.0 → 1.0.1

data/search_biomodel/ruby/1.8/gems/rake-0.9.2/test/test_rake_task_argument_parsing.rb

@@ -1,116 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-
-class TestRakeTaskArgumentParsing < Rake::TestCase
-  def setup
-    super
-
-    @app = Rake::Application.new
-  end
-
-  def test_name_only
-    name, args = @app.parse_task_string("name")
-    assert_equal "name", name
-    assert_equal [], args
-  end
-
-  def test_empty_args
-    name, args = @app.parse_task_string("name[]")
-    assert_equal "name", name
-    assert_equal [], args
-  end
-
-  def test_one_argument
-    name, args = @app.parse_task_string("name[one]")
-    assert_equal "name", name
-    assert_equal ["one"], args
-  end
-
-  def test_two_arguments
-    name, args = @app.parse_task_string("name[one,two]")
-    assert_equal "name", name
-    assert_equal ["one", "two"], args
-  end
-
-  def test_can_handle_spaces_between_args
-    name, args = @app.parse_task_string("name[one, two,\tthree , \tfour]")
-    assert_equal "name", name
-    assert_equal ["one", "two", "three", "four"], args
-  end
-
-  def test_keeps_embedded_spaces
-    name, args = @app.parse_task_string("name[a one ana, two]")
-    assert_equal "name", name
-    assert_equal ["a one ana", "two"], args
-  end
-
-  def test_terminal_width_using_env
-    app = Rake::Application.new
-    in_environment('RAKE_COLUMNS' => '1234') do
-      assert_equal 1234, app.terminal_width
-    end
-  end
-
-  def test_terminal_width_using_stty
-    app = Rake::Application.new
-    flexmock(app,
-      :unix? => true,
-      :dynamic_width_stty => 1235,
-      :dynamic_width_tput => 0)
-    in_environment('RAKE_COLUMNS' => nil) do
-      assert_equal 1235, app.terminal_width
-    end
-  end
-
-  def test_terminal_width_using_tput
-    app = Rake::Application.new
-    flexmock(app,
-      :unix? => true,
-      :dynamic_width_stty => 0,
-      :dynamic_width_tput => 1236)
-    in_environment('RAKE_COLUMNS' => nil) do
-      assert_equal 1236, app.terminal_width
-    end
-  end
-
-  def test_terminal_width_using_hardcoded_80
-    app = Rake::Application.new
-    flexmock(app, :unix? => false)
-    in_environment('RAKE_COLUMNS' => nil) do
-      assert_equal 80, app.terminal_width
-    end
-  end
-
-  def test_terminal_width_with_failure
-    app = Rake::Application.new
-    flexmock(app).should_receive(:unix?).and_throw(RuntimeError)
-    in_environment('RAKE_COLUMNS' => nil) do
-      assert_equal 80, app.terminal_width
-    end
-  end
-
-  def test_no_rakeopt
-    in_environment do
-      ARGV << '--trace'
-      app = Rake::Application.new
-      app.init
-      assert !app.options.silent
-    end
-  end
-
-  def test_rakeopt_with_blank_options
-    in_environment("RAKEOPT" => "") do
-      ARGV << '--trace'
-      app = Rake::Application.new
-      app.init
-      assert !app.options.silent
-    end
-  end
-
-  def test_rakeopt_with_silent_options
-    in_environment("RAKEOPT" => "-s") do
-      app = Rake::Application.new
-      app.init
-      assert app.options.silent
-    end
-  end
-end

data/search_biomodel/ruby/1.8/gems/rake-0.9.2/test/test_rake_task_arguments.rb

@@ -1,86 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-
-######################################################################
-class TestRakeTaskArguments < Rake::TestCase
-  def teardown
-    ENV.delete('rev')
-    ENV.delete('VER')
-  end
-
-  def test_empty_arg_list_is_empty
-    ta = Rake::TaskArguments.new([], [])
-    assert_equal({}, ta.to_hash)
-  end
-
-  def test_multiple_values_in_args
-    ta = Rake::TaskArguments.new([:a, :b, :c], [:one, :two, :three])
-    assert_equal({:a => :one, :b => :two, :c => :three}, ta.to_hash)
-  end
-
-  def test_to_s
-    ta = Rake::TaskArguments.new([:a, :b, :c], [1, 2, 3])
-    assert_equal ta.to_hash.inspect, ta.to_s
-    assert_equal ta.to_hash.inspect, ta.inspect
-  end
-
-  def test_enumerable_behavior
-    ta = Rake::TaskArguments.new([:a, :b, :c], [1, 2 ,3])
-    assert_equal [10, 20, 30], ta.collect { |k,v| v * 10 }.sort
-  end
-
-  def test_named_args
-    ta = Rake::TaskArguments.new(["aa", "bb"], [1, 2])
-    assert_equal 1, ta.aa
-    assert_equal 1, ta[:aa]
-    assert_equal 1, ta["aa"]
-    assert_equal 2, ta.bb
-    assert_nil ta.cc
-  end
-
-  def test_args_knows_its_names
-    ta = Rake::TaskArguments.new(["aa", "bb"], [1, 2])
-    assert_equal ["aa", "bb"], ta.names
-  end
-
-  def test_extra_names_are_nil
-    ta = Rake::TaskArguments.new(["aa", "bb", "cc"], [1, 2])
-    assert_nil ta.cc
-  end
-
-  def test_args_do_not_reference_env_values
-    ta = Rake::TaskArguments.new(["aa"], [1])
-    ENV['rev'] = "1.2"
-    ENV['VER'] = "2.3"
-    assert_nil ta.rev
-    assert_nil ta.ver
-  end
-
-  def test_creating_new_argument_scopes
-    parent = Rake::TaskArguments.new(['p'], [1])
-    child = parent.new_scope(['c', 'p'])
-    assert_equal({:p=>1}, child.to_hash)
-    assert_equal 1, child.p
-    assert_equal 1, child["p"]
-    assert_equal 1, child[:p]
-    assert_nil child.c
-  end
-
-  def test_child_hides_parent_arg_names
-    parent = Rake::TaskArguments.new(['aa'], [1])
-    child = Rake::TaskArguments.new(['aa'], [2], parent)
-    assert_equal 2, child.aa
-  end
-
-  def test_default_arguments_values_can_be_merged
-    ta = Rake::TaskArguments.new(["aa", "bb"], [nil, "original_val"])
-    ta.with_defaults({ :aa => 'default_val' })
-    assert_equal 'default_val', ta[:aa]
-    assert_equal 'original_val', ta[:bb]
-  end
-
-  def test_default_arguments_that_dont_match_names_are_ignored
-    ta = Rake::TaskArguments.new(["aa", "bb"], [nil, "original_val"])
-    ta.with_defaults({ "cc" => "default_val" })
-    assert_nil ta[:cc]
-  end
-end

data/search_biomodel/ruby/1.8/gems/rake-0.9.2/test/test_rake_task_lib.rb

@@ -1,9 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-require 'rake/tasklib'
-
-class TestRakeTaskLib < Rake::TestCase
-  def test_paste
-    tl = Rake::TaskLib.new
-    assert_equal :ab, tl.paste(:a, :b)
-  end
-end

data/search_biomodel/ruby/1.8/gems/rake-0.9.2/test/test_rake_task_manager.rb

@@ -1,145 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-
-class TestRakeTaskManager < Rake::TestCase
-
-  def setup
-    super
-
-    @tm = Rake::TestCase::TaskManager.new
-  end
-
-  def test_create_task_manager
-    refute_nil @tm
-    assert_equal [], @tm.tasks
-  end
-
-  def test_define_task
-    t = @tm.define_task(Rake::Task, :t)
-    assert_equal "t", t.name
-    assert_equal @tm, t.application
-  end
-
-  def test_name_lookup
-    t = @tm.define_task(Rake::Task, :t)
-    assert_equal t, @tm[:t]
-  end
-
-  def test_namespace_task_create
-    @tm.in_namespace("x") do
-      t = @tm.define_task(Rake::Task, :t)
-      assert_equal "x:t", t.name
-    end
-    assert_equal ["x:t"], @tm.tasks.collect { |t| t.name }
-  end
-
-  def test_anonymous_namespace
-    anon_ns = @tm.in_namespace(nil) do
-      t = @tm.define_task(Rake::Task, :t)
-      assert_equal "_anon_1:t", t.name
-    end
-    task = anon_ns[:t]
-    assert_equal "_anon_1:t", task.name
-  end
-
-  def test_create_filetask_in_namespace
-    @tm.in_namespace("x") do
-      t = @tm.define_task(Rake::FileTask, "fn")
-      assert_equal "fn", t.name
-    end
-    assert_equal ["fn"], @tm.tasks.collect { |t| t.name }
-  end
-
-  def test_namespace_yields_same_namespace_as_returned
-    yielded_namespace = nil
-    returned_namespace = @tm.in_namespace("x") do |ns|
-      yielded_namespace = ns
-    end
-    assert_equal returned_namespace, yielded_namespace
-  end
-
-  def test_name_lookup_with_implicit_file_tasks
-    t = @tm["README.rdoc"]
-    assert_equal "README.rdoc", t.name
-    assert Rake::FileTask === t
-  end
-
-  def test_name_lookup_with_nonexistent_task
-    assert_raises(RuntimeError) {
-      @tm["DOES NOT EXIST"]
-    }
-  end
-
-  def test_name_lookup_in_multiple_scopes
-    aa = nil
-    bb = nil
-    xx = @tm.define_task(Rake::Task, :xx)
-    top_z = @tm.define_task(Rake::Task, :z)
-    @tm.in_namespace("a") do
-      aa = @tm.define_task(Rake::Task, :aa)
-      mid_z = @tm.define_task(Rake::Task, :z)
-      @tm.in_namespace("b") do
-        bb = @tm.define_task(Rake::Task, :bb)
-        bot_z = @tm.define_task(Rake::Task, :z)
-
-        assert_equal ["a", "b"], @tm.current_scope
-
-        assert_equal bb, @tm["a:b:bb"]
-        assert_equal aa, @tm["a:aa"]
-        assert_equal xx, @tm["xx"]
-        assert_equal bot_z, @tm["z"]
-        assert_equal mid_z, @tm["^z"]
-        assert_equal top_z, @tm["^^z"]
-        assert_equal top_z, @tm["rake:z"]
-      end
-
-      assert_equal ["a"], @tm.current_scope
-
-      assert_equal bb, @tm["a:b:bb"]
-      assert_equal aa, @tm["a:aa"]
-      assert_equal xx, @tm["xx"]
-      assert_equal bb, @tm["b:bb"]
-      assert_equal aa, @tm["aa"]
-      assert_equal mid_z, @tm["z"]
-      assert_equal top_z, @tm["^z"]
-      assert_equal top_z, @tm["rake:z"]
-    end
-
-    assert_equal [], @tm.current_scope
-
-    assert_equal [], xx.scope
-    assert_equal ['a'], aa.scope
-    assert_equal ['a', 'b'], bb.scope
-  end
-
-  def test_lookup_with_explicit_scopes
-    t1, t2, t3, s = (0...4).collect { nil }
-    t1 = @tm.define_task(Rake::Task, :t)
-    @tm.in_namespace("a") do
-      t2 = @tm.define_task(Rake::Task, :t)
-      s =  @tm.define_task(Rake::Task, :s)
-      @tm.in_namespace("b") do
-        t3 = @tm.define_task(Rake::Task, :t)
-      end
-    end
-    assert_equal t1, @tm[:t, []]
-    assert_equal t2, @tm[:t, ["a"]]
-    assert_equal t3, @tm[:t, ["a", "b"]]
-    assert_equal s,  @tm[:s, ["a", "b"]]
-    assert_equal s,  @tm[:s, ["a"]]
-  end
-
-  def test_correctly_scoped_prerequisites_are_invoked
-    values = []
-    @tm = Rake::Application.new
-    @tm.define_task(Rake::Task, :z) do values << "top z" end
-    @tm.in_namespace("a") do
-      @tm.define_task(Rake::Task, :z) do values << "next z" end
-      @tm.define_task(Rake::Task, :x => :z)
-    end
-
-    @tm["a:x"].invoke
-    assert_equal ["next z"], values
-  end
-
-end
-

data/search_biomodel/ruby/1.8/gems/rake-0.9.2/test/test_rake_task_manager_argument_resolution.rb

@@ -1,36 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-
-class TestRakeTaskManagerArgumentResolution < Rake::TestCase
-
-  def setup
-    super
-
-    Rake.application.options.ignore_deprecate = true
-  end
-
-  def teardown
-    Rake.application.options.ignore_deprecate = false
-
-    super
-  end
-
-  def test_good_arg_patterns
-    assert_equal [:t, [], []],       task(:t)
-    assert_equal [:t, [], [:x]],     task(:t => :x)
-    assert_equal [:t, [], [:x, :y]], task(:t => [:x, :y])
-
-    assert_equal [:t, [:a, :b], []],       task(:t, :a, :b)
-    assert_equal [:t, [], [:x]],           task(:t, :needs => :x)
-    assert_equal [:t, [:a, :b], [:x]],     task(:t, :a, :b, :needs => :x)
-    assert_equal [:t, [:a, :b], [:x, :y]], task(:t, :a, :b, :needs => [:x, :y])
-
-    assert_equal [:t, [:a, :b], []],       task(:t, [:a, :b])
-    assert_equal [:t, [:a, :b], [:x]],     task(:t, [:a, :b] => :x)
-    assert_equal [:t, [:a, :b], [:x, :y]], task(:t, [:a, :b] => [:x, :y])
-  end
-
-  def task(*args)
-    tm = Rake::TestCase::TaskManager.new
-    tm.resolve_args(args)
-  end
-end

data/search_biomodel/ruby/1.8/gems/rake-0.9.2/test/test_rake_task_with_arguments.rb

@@ -1,162 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-
-class TestRakeTaskWithArguments < Rake::TestCase
-  include Rake
-
-  def setup
-    super
-
-    Task.clear
-    Rake::TaskManager.record_task_metadata = true
-  end
-
-  def teardown
-    Rake::TaskManager.record_task_metadata = false
-
-    super
-  end
-
-  def test_no_args_given
-    t = task :t
-    assert_equal [], t.arg_names
-  end
-
-  def test_args_given
-    t = task :t, :a, :b
-    assert_equal [:a, :b], t.arg_names
-  end
-
-  def test_name_and_needs
-    t = task(:t => [:pre])
-    assert_equal "t", t.name
-    assert_equal [], t.arg_names
-    assert_equal ["pre"], t.prerequisites
-  end
-
-  def test_name_args_and_explicit_needs
-    ignore_deprecations do
-      t = task(:t, :x, :y, :needs => [:pre])
-      assert_equal "t", t.name
-      assert_equal [:x, :y], t.arg_names
-      assert_equal ["pre"], t.prerequisites
-    end
-  end
-
-  def test_illegal_keys_in_task_name_hash
-    ignore_deprecations do
-      assert_raises RuntimeError do
-        t = task(:t, :x, :y => 1, :needs => [:pre])
-      end
-    end
-  end
-
-  def test_arg_list_is_empty_if_no_args_given
-    t = task(:t) { |tt, args| assert_equal({}, args.to_hash) }
-    t.invoke(1, 2, 3)
-  end
-
-  def test_tasks_can_access_arguments_as_hash
-    t = task :t, :a, :b, :c do |tt, args|
-      assert_equal({:a => 1, :b => 2, :c => 3}, args.to_hash)
-      assert_equal 1, args[:a]
-      assert_equal 2, args[:b]
-      assert_equal 3, args[:c]
-      assert_equal 1, args.a
-      assert_equal 2, args.b
-      assert_equal 3, args.c
-    end
-    t.invoke(1, 2, 3)
-  end
-
-  def test_actions_of_various_arity_are_ok_with_args
-    notes = []
-    t = task(:t, :x) do
-      notes << :a
-    end
-    t.enhance do | |
-      notes << :b
-    end
-    t.enhance do |task|
-      notes << :c
-      assert_kind_of Task, task
-    end
-    t.enhance do |t2, args|
-      notes << :d
-      assert_equal t, t2
-      assert_equal({:x => 1}, args.to_hash)
-    end
-    t.invoke(1)
-    assert_equal [:a, :b, :c, :d], notes
-  end
-
-  def test_arguments_are_passed_to_block
-    t = task(:t, :a, :b) { |tt, args|
-      assert_equal( { :a => 1, :b => 2 }, args.to_hash )
-    }
-    t.invoke(1, 2)
-  end
-
-  def test_extra_parameters_are_ignored
-    t = task(:t, :a) { |tt, args|
-      assert_equal 1, args.a
-      assert_nil args.b
-    }
-    t.invoke(1, 2)
-  end
-
-  def test_arguments_are_passed_to_all_blocks
-    counter = 0
-    t = task :t, :a
-    task :t do |tt, args|
-      assert_equal 1, args.a
-      counter += 1
-    end
-    task :t do |tt, args|
-      assert_equal 1, args.a
-      counter += 1
-    end
-    t.invoke(1)
-    assert_equal 2, counter
-  end
-
-  def test_block_with_no_parameters_is_ok
-    t = task(:t) { }
-    t.invoke(1, 2)
-  end
-
-  def test_name_with_args
-    desc "T"
-    t = task(:tt, :a, :b)
-    assert_equal "tt", t.name
-    assert_equal "T", t.comment
-    assert_equal "[a,b]", t.arg_description
-    assert_equal "tt[a,b]", t.name_with_args
-    assert_equal [:a, :b],t.arg_names
-  end
-
-  def test_named_args_are_passed_to_prereqs
-    value = nil
-    pre = task(:pre, :rev) { |t, args| value = args.rev }
-    t = task(:t, [:name, :rev] => [:pre])
-    t.invoke("bill", "1.2")
-    assert_equal "1.2", value
-  end
-
-  def test_args_not_passed_if_no_prereq_names
-    pre = task(:pre) { |t, args|
-      assert_equal({}, args.to_hash)
-      assert_equal "bill", args.name
-    }
-    t = task(:t, [:name, :rev] => [:pre])
-    t.invoke("bill", "1.2")
-  end
-
-  def test_args_not_passed_if_no_arg_names
-    pre = task(:pre, :rev) { |t, args|
-      assert_equal({}, args.to_hash)
-    }
-    t = task(:t  => [:pre])
-    t.invoke("bill", "1.2")
-  end
-end
-

data/search_biomodel/ruby/1.8/gems/rake-0.9.2/test/test_rake_test_task.rb

@@ -1,122 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-require 'rake/testtask'
-
-class TestRakeTestTask < Rake::TestCase
-  include Rake
-
-  def setup
-    super
-
-    Task.clear
-    ENV.delete('TEST')
-  end
-
-  def teardown
-    FileUtils.rm_rf("testdata")
-
-    super
-  end
-
-  def test_no_task
-    assert ! Task.task_defined?(:test)
-  end
-
-  def test_defaults
-    tt = Rake::TestTask.new do |t| end
-    refute_nil tt
-    assert_equal :test, tt.name
-    assert_equal ['lib'], tt.libs
-    assert_equal 'test/test*.rb', tt.pattern
-    assert_equal false, tt.verbose
-    assert Task.task_defined?(:test)
-  end
-
-  def test_non_defaults
-    tt = Rake::TestTask.new(:example) do |t|
-      t.libs = ['src', 'ext']
-      t.pattern = 'test/tc_*.rb'
-      t.verbose = true
-    end
-    refute_nil tt
-    assert_equal :example, tt.name
-    assert_equal ['src', 'ext'], tt.libs
-    assert_equal 'test/tc_*.rb', tt.pattern
-    assert_equal true, tt.verbose
-    assert Task.task_defined?(:example)
-  end
-
-  def test_pattern
-    tt = Rake::TestTask.new do |t|
-      t.pattern = '*.rb'
-    end
-    assert_equal ['*.rb'], tt.file_list.to_a
-  end
-
-  def test_env_test
-    ENV['TEST'] = 'testfile.rb'
-    tt = Rake::TestTask.new do |t|
-      t.pattern = '*'
-    end
-    assert_equal ["testfile.rb"], tt.file_list.to_a
-  end
-
-  def test_test_files
-    tt = Rake::TestTask.new do |t|
-      t.test_files = FileList['a.rb', 'b.rb']
-    end
-    assert_equal ["a.rb", 'b.rb'], tt.file_list.to_a
-  end
-
-  def test_both_pattern_and_test_files
-    tt = Rake::TestTask.new do |t|
-      t.test_files = FileList['a.rb', 'b.rb']
-      t.pattern = '*.rb'
-    end
-    assert_equal ['a.rb', 'b.rb', '*.rb'], tt.file_list.to_a
-  end
-
-  def test_direct_run_has_quoted_paths
-    test_task = Rake::TestTask.new(:tx) do |t|
-      t.loader = :direct
-    end
-    assert_match(/-e ".*"/, test_task.run_code)
-  end
-
-  def test_testrb_run_has_quoted_paths_on_ruby_182
-    test_task = Rake::TestTask.new(:tx) do |t|
-      t.loader = :testrb
-    end
-    flexmock(test_task).should_receive(:ruby_version).and_return('1.8.2')
-    assert_match(/^-S testrb +".*"$/, test_task.run_code)
-  end
-
-  def test_testrb_run_has_quoted_paths_on_ruby_186
-    test_task = Rake::TestTask.new(:tx) do |t|
-      t.loader = :testrb
-    end
-    flexmock(test_task).should_receive(:ruby_version).and_return('1.8.6')
-    assert_match(/^-S testrb +$/, test_task.run_code)
-  end
-
-  def test_rake_run_has_quoted_paths
-    test_task = Rake::TestTask.new(:tx) do |t|
-      t.loader = :rake
-    end
-    assert_match(/".*"/, test_task.run_code)
-  end
-
-  def test_nested_libs_will_be_flattened
-    test_task = Rake::TestTask.new(:tx) do |t|
-      t.libs << ["A", "B"]
-    end
-    sep = File::PATH_SEPARATOR
-    assert_match(/lib#{sep}A#{sep}B/, test_task.ruby_opts_string)
-  end
-
-  def test_empty_lib_path_implies_no_dash_I_option
-    test_task = Rake::TestTask.new(:tx) do |t|
-      t.libs = []
-    end
-    refute_match(/-I/, test_task.ruby_opts_string)
-  end
-end