rbbt-util 3.2.1 → 4.0.0

data/test/rbbt/util/test_rake.rb

@@ -1,54 +0,0 @@
-require File.join(File.expand_path(File.dirname(__FILE__)), '../..', 'test_helper.rb')
-require 'rbbt/util/rake'
-
-class TestRake < Test::Unit::TestCase
-  def test_run
-    rakefile=<<-EOF
-require 'rbbt/util/rake'
-
-file "foo" do |t|
-  Open.write(t.name, 'bar')
-end
-    EOF
-
-    TmpFile.with_file(rakefile) do |f|
-      RakeHelper.run f, :foo
-
-      assert File.exists? "foo"
-      FileUtils.rm "foo"
-    end
-  end
-
-  def test_run_default
-    rakefile=<<-EOF
-require 'rbbt/util/rake'
-
-file "foo" do |t|
-  Open.write(t.name, 'bar')
-end
-    EOF
-
-    TmpFile.with_file(rakefile) do |f|
-      RakeHelper.run f
-
-      assert File.exists? "foo"
-      FileUtils.rm "foo"
-    end
-  end
-
-
-  def test_files
-    rakefile=<<-EOF
-require 'rbbt/util/rake'
-
-file "foo" do |t|
-  Open.write(t.name, 'bar')
-end
-    EOF
-
-    TmpFile.with_file(rakefile) do |f|
-      assert RakeHelper.files(f).include? "foo"
-    end
-  end
-end
-

data/test/rbbt/util/test_resource.rb

@@ -1,77 +0,0 @@
-require File.join(File.expand_path(File.dirname(__FILE__)), '../..', 'test_helper.rb')
-require 'rbbt/util/resource'
-
-
-module Rbbt
-  extend Resource
-
-  tmp.test_string.define_as_string "Test String"
-  tmp.url.define_as_url "http://www.ruby-lang.org/es/"
-  tmp.Rakefile.define_as_string <<-EOF
-file 'foo' do |t|
-   Open.write(t.name, "Test String")
-end
-  EOF
-
-end
-
-Open.cachedir = Rbbt.tmp.cache.find :user
-
-module Phgx
-  extend Resource
-end
-
-
-class TestResource < Test::Unit::TestCase
-  def test_methods
-    assert Resource.methods.collect{|m| m.to_s}.include?("resources") 
-    assert ! Resource.methods.collect{|m| m.to_s}.include?("pkgdir")
-    assert ! Phgx.methods.collect{|m| m.to_s}.include?("resources")
-    assert Phgx.methods.collect{|m| m.to_s}.include?("pkgdir")
-
-  end
-  def test_resolve
-    assert_equal File.join(ENV['HOME'], '.rbbt/etc/foo'), Resource.resolve('etc/foo', '', :user)
-    assert_equal File.join(ENV['HOME'], '.phgx/etc/foo'), Resource.resolve('etc/foo', 'phgx', :user)
-
-    assert_equal File.join('/', 'etc/foo'), Resource.resolve('etc/foo', '', :global)
-    assert_equal File.join('/', 'etc/phgx/foo'), Resource.resolve('etc/foo', 'phgx', :global)
-
-    assert_equal File.join('/usr/local', 'etc/foo'), Resource.resolve('etc/foo', '', :local)
-    assert_equal File.join('/usr/local', 'etc/phgx/foo'), Resource.resolve('etc/foo', 'phgx', :local)
-
-    assert_equal File.expand_path(File.join(File.dirname(File.expand_path(__FILE__)), '../../../', 'etc/foo')), Resource.resolve('etc/foo', '', :lib)
-    assert_equal File.expand_path(File.join(File.dirname(File.expand_path(__FILE__)), '../../../', 'etc/foo')), Resource.resolve('etc/foo', 'phgx', :lib)
-
-    assert_equal File.join(ENV['HOME'], '.rbbt/etc/foo'), Resource.resolve('etc/foo', '')
-    assert_equal File.join(ENV['HOME'], '.phgx/etc/foo'), Resource.resolve('etc/foo', 'phgx')
-  end
-
-  def test_base
-    assert_equal Rbbt, Rbbt.base
-  end
-
-  def test_path
-    assert_equal File.join(ENV['HOME'], '.rbbt/etc/foo'), Rbbt.etc.foo.find
-    assert_equal File.join(ENV['HOME'], '.rbbt/etc/foo'), Rbbt.etc.foo.find(:user)
-    assert_equal File.join(ENV['HOME'], '.phgx/etc/foo'), Phgx.etc.foo.find
-    assert_equal File.join(ENV['HOME'], '.phgx/etc/foo'), Phgx.etc.foo.find(:user)
-  end
-
-  def test_libdir
-    assert File.exists? Rbbt.share.lib.R["util.R"].find :lib
-    assert File.exists? Rbbt.share.lib.R["util.R"].find 
-  end
-
-  def test_define
-    begin
-      assert_equal "Test String", Rbbt.tmp.test_string.read
-      assert_equal "Test String", Rbbt.tmp.work.foo.read
-    rescue
-    ensure
-      FileUtils.rm Rbbt.tmp.test_string.find if File.exists? Rbbt.tmp.test_string.find
-      FileUtils.rm Rbbt.tmp.url.find if File.exists? Rbbt.tmp.url.find
-    end
-  end
-end
-

data/test/rbbt/util/test_task.rb

@@ -1,133 +0,0 @@
-require File.join(File.expand_path(File.dirname(__FILE__)), '../..', 'test_helper.rb')
-require 'rbbt/util/task'
-
-Task.basedir = Rbbt.tmp.test.taskjobs.find :user
-
-class TestTask < Test::Unit::TestCase
-  def test_task
-    $true
-    task = Task.new(:test_task) do $true = true end
-    job = task.job(:job1)
-    job.start
-
-    assert $true
-  end
-
-  def test_task_fork
-    TmpFile.with_file do |f|
-      task = Task.new(:test_task) do Open.write(f, "Test") end
-      job = task.job(:job1)
-      job.fork
-      job.join
-
-      assert File.exists? f
-    end
-  end
-
-  def test_task_options
-    TmpFile.with_file do |f|
-      task = Task.new(:test_task, nil, :name) do |name| Open.write(f, name) end
-      job = task.job(:job1, "TestName")
-      assert_equal "job1" << "_" << Misc.hash2md5(:name => "TestName"), job.id
-      job.fork
-      job.join
-
-      assert File.exists? f
-      assert_equal "TestName", File.open(f).read
-    end
-  end
-
-  def test_task_options_from_hash
-    TmpFile.with_file do |f|
-      task = Task.new(:test_task, nil, :name) do |name| Open.write(f, name) end
-      job = task.job(:job1, :name => "TestName")
-      assert_equal "job1" << "_" << Misc.hash2md5(:name => "TestName"), job.id
-      job.fork
-      job.join
-
-      assert File.exists? f
-      assert_equal "TestName", File.open(f).read
-    end
-  end
-
-
-  def test_task_result
-    task = Task.new(:test_task, nil, :name) do |name| name end
-    job = task.job(:job1, "TestName")
-    assert_equal "TestName", job.fork.join.load
-  end
-
-  def test_task_info
-    task = Task.new(:test_task, nil, :name) do |name| name end
-    job = task.job(:job1, "TestName")
-    assert_equal "TestName", job.fork.join.info[:options][:name]
-  end
-
-  def test_task_status
-    task = Task.new(:test_task, nil, :name) do |name| 
-      step :one
-      name 
-    end
-    job = task.job(:job1, "TestName")
-    assert_equal "TestName", job.fork.join.info[:options][:name]
-  end
-
-  def test_task_reopen
-    task = Task.new(:test_task, nil, :name) do |name| name end
-    job = task.job(:job1, "TestName")
-    assert_equal "TestName", job.fork.join.info[:options][:name]
-    job = task.job(:job1, "TestName")
-    assert_equal "TestName", job.join.info[:options][:name]
-  end
-
-  def test_marshal_persistence
-    task = Task.new(:test_task, :marshal) do 
-      {:a => :b}
-    end
-    job = task.job(:job1).fork.join
-    assert Hash === job.load
-    assert_equal :b, job.load[:a]
-  end
-
-  def test_yaml_persistence
-    task = Task.new(:test_task, :yaml) do 
-      {:a => :b}
-    end
-    job = task.job(:job1).fork.join
-    assert Hash === job.load
-    assert_equal :b, job.load[:a]
-    assert_equal :b, YAML.load(job.open)[:a]
-  end
-
-  def test_tsv_persistence
-    task = Task.new(:test_task, :tsv) do 
-      tsv = TSV.new({})
-      tsv.key_field = "A"
-      tsv.fields = ["B"]
-      tsv.type = :list
-      tsv["a"] = ["b"]
-      tsv
-    end
-    job = task.job(:job1).fork.join
-    assert TSV === job.load
-    assert_equal "b", job.load["a"]["B"]
-  end
-
-  def test_clean
-    task = Task.new(:test_task, :tsv) do 
-      tsv = TSV.new({})
-      tsv.key_field = "A"
-      tsv.fields = ["B"]
-      tsv.type = :list
-      tsv["a"] = ["b"]
-      tsv
-    end
-    job = task.job(:job1).fork.join
-
-    assert File.exists?(job.path)
-    job.clean
-    assert (not File.exists?(job.path))
-  end
-
-end
-

data/test/rbbt/util/test_tc_hash.rb

@@ -1,144 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
-require 'rbbt/util/tmpfile'
-require 'rbbt/util/tc_hash'
-
-class TestTCHash < Test::Unit::TestCase
-  def test_each
-    TmpFile.with_file do |f|
-      t = TCHash.new f
-      t["1"] = 2
-      t["2"] = 3
-
-      t.collect do |k,v| 
-        ["1", "2"].include? k 
-      end
-    end
-  end
-
-  def test_serializer
-    TmpFile.with_file do |f|
-      t = TCHash.new f, TCHash::StringSerializer
-      t["1"] = 2
-      t["2"] = 3
-      t.read
-
-      t.collect do |k,v| 
-        ["1", "2"].include? k 
-      end
-    end
-  end
-
-  def test_stringArraySerializer
-    TmpFile.with_file do |f|
-      t = TCHash.get f, true, TCHash::StringArraySerializer
-      t["1"] = [1,2]
-      t["2"] = [3,4]
-
-      t = TCHash.get f
-      t.collect do |k,v| 
-        assert_equal ["1", "2"], t["1"] 
-      end
-    end
-  end
-
-  def test_stringDoubleArraySerializer
-    TmpFile.with_file do |f|
-      t = TCHash.get f, true, TCHash::StringDoubleArraySerializer
-      t["1"] = [[1],[2]]
-      t["2"] = [[3],[4,5]]
-
-      t = TCHash.get f
-      t.collect do |k,v| 
-       assert_equal [["3"],["4","5"]], t["2"]
-      end
-    end
-  end
-
-  def test_stringDoubleArraySerializer
-    TmpFile.with_file do |f|
-      t = TCHash.get f, true, TCHash::TSVSerializer
-      tsv = TSV.new({})
-      tsv["1"] = [[1],[2]]
-      tsv["2"] = [[3],[4,5]]
-      t["TSV"] = tsv
-
-      t = TCHash.get f
-      t.collect do |k,v| 
-       assert_equal [["3"],["4","5"]], t["TSV"]["2"]
-      end
-    end
-  end
-
- 
-  def test_serializer_alias
-    TmpFile.with_file do |f|
-      t = TCHash.get f, true, :double
-      t["1"] = [[1],[2]]
-      t["2"] = [[3],[4,5]]
-
-      t = TCHash.get f
-      assert_equal [["3"],["4","5"]], t["2"]
-    end
-  end
-
-  def test_non_blocking
-    TmpFile.with_file do |f|
-      t = TCHash.get f, true, :double
-      t["1"] = [[1],[2]]
-      t["2"] = [[3],[4,5]]
-      t.close
-
-      pid = Process.fork do
-        t2 = TCHash.get f, false, :double
-        assert_equal [["3"],["4","5"]], t2["2"]
-        t2.read
-        exit
-      end
-
-      t2 = TCHash.get f, false, :double
-      assert_equal [["3"],["4","5"]], t2["2"]
-      t2.read
-
-      Process.wait pid
-    end
-  end
-
-  def test_serializer_alias
-    TmpFile.with_file do |f|
-      t = TCHash.get f, true, :double
-      t["1"] = [[1],[2]]
-      t["2"] = [[3],[4,5]]
-
-      t = TCHash.get f
-      assert_equal [["3"],["4","5"]], t["2"]
-
-      t.close
-      TCHash::CONNECTIONS.clear
-
-      t = TCHash.get f
-      assert_equal [["3"],["4","5"]], t["2"]
-    end
-  end
-
-  def test_serializer_reload
-    TmpFile.with_file do |f|
-      t = TCHash.get f, true, :double
-      t["1"] = [[1],[2]]
-      t["2"] = [[3],[4,5]]
-
-      t = TCHash.get f
-      assert_equal TCHash::StringDoubleArraySerializer, t.serializer
-      assert_equal [["3"],["4","5"]], t["2"]
-
-      t.close
-      TCHash::CONNECTIONS.clear
-
-      t = TCHash.get f
-      assert_equal [["3"],["4","5"]], t["2"]
-    end
-  end
-
-
-
-end
-

data/test/rbbt/util/test_tsv.rb

@@ -1,221 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
-require 'rbbt/util/tsv'
-require 'rbbt/util/tmpfile'
-
-class TestTSV < Test::Unit::TestCase
-
-  def test_tsv
-    content =<<-EOF
-#Id    ValueA    ValueB    OtherID
-row1    a|aa|aaa    b    Id1|Id2
-row2    A    B    Id3
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.new(File.open(filename), :double, :sep => /\s+/, :key => "OtherID")
-      assert_equal :double, tsv.type
-      assert_equal "OtherID", tsv.key_field
-      assert_equal ["Id", "ValueA", "ValueB"], tsv.fields
-      assert_equal ["a", "aa", "aaa"], tsv["Id1"][1]
-      assert_equal ["a", "aa", "aaa"], tsv["Id2"][1]
-    end
-  end
-
-  def test_grep
-    content =<<-EOF
-#Id    ValueA    ValueB    OtherID
-row1    a|aa|aaa    b    Id1|Id2
-row2    A    B    Id3
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.new(File.open(filename), :sep => /\s+/, :grep => %w(row1))
-      assert tsv.keys.include? "row1"
-      assert( ! tsv.keys.include?("row2"))
-    end
-  end
-
-  def test_open_stringoptions
-    content =<<-EOF
-#Id    ValueA    ValueB    OtherID
-row1    a|aa|aaa    b    Id1|Id2
-row2    A    B    Id3
-row3    a    C    Id4
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.new(filename + '#:sep=/\s+/')
-      assert_equal ["A"], tsv["row2"]["ValueA"]
-    end
-  end
-
-  def test_headers
-    content =<<-EOF
-#ID ValueA ValueB Comment
-row1 a b c
-row2 A B C
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      assert_equal ['ID', 'ValueA', 'ValueB', 'Comment'], TSV.headers(filename, :sep => ' ')
-      assert_equal nil, TSV.headers(filename, :sep => ' ', :header_hash => "##")
-    end
-  end
-
-  def test_headerless
-    content =<<-EOF
-row1 a b c
-row2 A B C
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      assert_equal 3, TSV.new(filename, :sep => ' ')['row1'].length
-    end
-  end
-
-  def test_extra
-    content =<<-EOF
-#Id    ValueA    ValueB    OtherID
-row1    a|aa|aaa    b    Id1|Id2
-row2    A    B    Id3
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.new(File.open(filename), :sep => /\s+/, :key => "OtherID", :fields => 2)
-      assert_equal ["b"], tsv["Id2"][0]
-      tsv = TSV.new(File.open(filename), :sep => /\s+/, :key => "OtherID", :fields => 'ValueB')
-      assert_equal ["b"], tsv["Id2"][0]
-    end
-  end
-
-  def test_case
-    content =<<-EOF
-#Id    ValueA    ValueB    OtherID
-row1    a|aa|aaa    b    Id1|Id2
-row2    A    B    Id3
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.new(File.open(filename), :sep => /\s+/, :key => "OtherID", :case_insensitive => true)
-      assert_equal "OtherID", tsv.key_field
-      assert_equal ["Id", "ValueA", "ValueB"], tsv.fields
-      assert_equal ["a", "aa", "aaa"], tsv["id1"][1]
-      assert_equal ["a", "aa", "aaa"], tsv["Id2"][1]
-
-      tsv = TSV.new(File.open(filename), :sep => /\s+/, :key => "OtherID", :case_insensitive => false)
-      assert_equal "OtherID", tsv.key_field
-      assert_equal ["Id", "ValueA", "ValueB"], tsv.fields
-      assert_nil tsv["id1"]
-    end
-  end
-
-  def test_persistence
-    content =<<-EOF
-#Id    ValueA    ValueB    OtherID
-row1    a|aa|aaa    b    Id1|Id2
-row2    A    B    Id3
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.new(filename, :sep => /\s+/, :key => "OtherID", :persistence => true)
-      assert_equal ["Id", "ValueA", "ValueB"], tsv.fields
-
-      tsv.write
-      tsv['Id4'] = [["row3"],["aA"],["bB","bbBB"]]
-      assert_equal ["aA"], tsv["Id4"][1]
-      tsv = TSV.new(File.open(filename), :sep => /\s+/, :key => "OtherID", :persistence => true)
-      assert_equal ["Id", "ValueA", "ValueB"], tsv.fields
-
-      assert_equal ["aA"], tsv["Id4"][1]
-      assert_equal [["b"],["B"]], tsv.values_at("Id1", "Id3").collect{|values| values[2]}
-      tsv = TSV.new(File.open(filename), :flat, :sep => /\s+/, :key => "OtherID", :persistence => false)
-      assert(tsv["Id3"].include? "A")
-    end
-  end
-
-  def test_named_array
-    content =<<-EOF
-#Id    ValueA    ValueB    OtherID
-row1    a|aa|aaa    b    Id1|Id2
-row2    A    B    Id3
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.new(File.open(filename), :sep => /\s+/, :key => "OtherID", :case_insensitive => true)
-      assert_equal "OtherID", tsv.key_field
-      assert_equal ["Id", "ValueA", "ValueB"], tsv.fields
-      assert_equal ["a", "aa", "aaa"], tsv["id1"][1]
-      assert_equal ["a", "aa", "aaa"], tsv["Id2"]["ValueA"]
-   end
-  end
-
-  def test_one_col
-    content =<<-EOF
-#Id
-row1
-row2
-    EOF
-
-    TmpFile.with_file(content) do |filename|
-      tsv = TSV.new(File.open(filename), :sep => /\s+/)
-      assert_equal "Id", tsv.key_field
-      assert_equal [], tsv.fields
-   end
-  end
-
-
-  def test_case_insensitive
-     content1 =<<-EOF
-#: :sep=/\\s+/#:case_insensitive=false
-#Id    ValueA    ValueB
-row1    a|aa|aaa    b
-row2    A    B
-    EOF
-
-   tsv1 = tsv2 = identifiers = nil
-    TmpFile.with_file(content1) do |filename|
-      tsv1 = TSV.new(File.open(filename), :key => "ValueA")
-      assert !tsv1.case_insensitive
-      assert tsv1.include? "A"
-    end
-  end
-
-  def test_create_array
-    tsv = TSV.new(%w(a b c))
-    assert_equal %w(a b c).sort, tsv.keys.sort
-    assert_equal [[]] * tsv.keys.length, tsv.values
-  end
-
-  def test_persistence_data
-     content1 =<<-EOF
-#: :sep=/\\s+/#:case_insensitive=false
-#Id    ValueA    ValueB
-row1    a|aa|aaa    b
-row2    A    B
-    EOF
-
-   tsv1 = tsv2 = identifiers = nil
-    TmpFile.with_file(content1) do |filename|
-      TmpFile.with_file do |tchashfile|
-        tchash = TCHash.get(tchashfile, true)
-        tsv1 = TSV.new(File.open(filename), :key => "ValueA", :persistence_data => tchash)
-        assert TCHash === tsv1.data
-        assert !tsv1.case_insensitive
-        assert tsv1.include? "A"
-        ddd tsv1.filename
-
-        tsv1 = TSV.new(tchash, :key => "ValueA")
-        assert TCHash === tsv1.data
-        assert !tsv1.case_insensitive
-        assert tsv1.include? "A"
-        ddd tsv1.filename
-      end
-    end
- 
-  end
-
-  def test_with_hash
-    assert TSV === TSV.new {}, :list
-  end
-end
-