rbbt-util 5.43.0 → 5.44.0

data/test/rbbt/test_annotations.rb

@@ -1,167 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
-require 'rbbt/annotations'
-require 'rbbt/util/tmpfile'
-require 'test/unit'
-
-module AnnotatedString
-  extend Annotation
-  self.annotation :annotation_str
-
-  def add_annot
-    self + annotation_str
-  end
-end
-
-module AnnotatedString2
-  extend Annotation
-  include AnnotatedString
-  self.annotation :annotation_str2
-end
-
-class TestAnnotations < Test::Unit::TestCase
-
-  def test_annotated_string
-    assert_equal %w(annotation_str), AnnotatedString.annotations.collect{|a| a.to_s}
-  end
-
-  def test_string
-    str = "string"
-    annotation_str = "Annotation String"
-    AnnotatedString.setup(str, annotation_str)
-    assert_equal [AnnotatedString], str.annotation_types
-    assert_equal annotation_str, str.annotation_str
-  end
-
-  def test_array
-    ary = ["string"]
-    annotation_str = "Annotation String"
-    ary.extend AnnotatedArray
-    AnnotatedString.setup(ary, annotation_str)
-    assert_equal [AnnotatedString], ary.annotation_types
-    assert_equal annotation_str, ary.annotation_str
-    assert_equal annotation_str, ary[0].annotation_str
-  end
-
-
-  def test_info
-    ary = ["string"]
-    annotation_str = "Annotation String"
-    AnnotatedString.setup(ary, annotation_str)
-    
-    assert_equal({:annotation_str => annotation_str, :annotation_types => [AnnotatedString], :annotated_array => true}, ary.info)
-  end
-
-  def test_load
-    str = "string"
-    annotation_str = "Annotation String"
-    info = {:annotation_str => annotation_str, :annotation_types => [AnnotatedString]}
-
-    Annotated.load_entity(str, info)
-    assert_equal annotation_str, str.annotation_str
-  end
-
-  def test_json
-    str1 = "string1"
-    annotation_str1 = "Annotation String 1"
-    str2 = "string2"
-    annotation_str2 = "Annotation String 2"
-    AnnotatedString.setup(str1, annotation_str1)
-    AnnotatedString.setup(str2, annotation_str2)
-  end
-
-  def test_tsv
-    str1 = "string1"
-    annotation_str1 = "Annotation String 1"
-    str2 = "string2"
-    annotation_str2 = "Annotation String 2"
-    AnnotatedString.setup(str1, annotation_str1)
-    AnnotatedString.setup(str2, annotation_str2)
-    
-    assert_equal str1, Annotated.tsv([str1, str2], :all).tap{|t| t.unnamed = false}[str1.id + "#0"]["literal"] 
-    assert_equal annotation_str1, Annotated.tsv([str1, str2], :all).tap{|t| t.unnamed = false}[str1.id + "#0"]["annotation_str"] 
-    assert_equal str1, Annotated.tsv([str1, str2], :all).tap{|t| t.unnamed = false}[str1.id + "#0"]["literal"] 
-    assert_equal annotation_str1, Annotated.tsv([str1, str2], :all).tap{|t| t.unnamed = false}[str1.id + "#0"]["annotation_str"] 
-    assert_equal annotation_str1, Annotated.tsv([str1, str2], :annotation_str, :JSON).tap{|t| t.unnamed = false}[str1.id + "#0"]["annotation_str"] 
-  end
-
-  def test_literal
-    str = "string"
-    annotation_str = "Annotation String"
-    AnnotatedString.setup(str, annotation_str)
-    assert_equal ["string"], str.tsv_values("literal")
-  end
-
-  def test_load_tsv
-    str1 = "string1"
-    annotation_str1 = "Annotation String 1"
-    str2 = "string2"
-    annotation_str2 = "Annotation String 2"
-    AnnotatedString.setup(str1, annotation_str1)
-    AnnotatedString.setup(str2, annotation_str2)
-    assert_equal annotation_str1, Annotated.load_tsv(Annotated.tsv([str1, str2], :all)).sort.first.annotation_str
-    assert_equal str1, Annotated.load_tsv(Annotated.tsv([str1, str2], :literal, :JSON)).sort.first
-  end
-
-  def test_load_array_tsv
-    str1 = "string1"
-    str2 = "string2"
-    a = [str1, str2]
-    annotation_str = "Annotation String 2"
-    AnnotatedString.setup(a, annotation_str)
-    a.extend AnnotatedArray
-
-
-    assert_equal annotation_str, Annotated.load_tsv(Annotated.tsv(a, :all)).annotation_str
-
-    assert_equal str2, Annotated.load_tsv(Annotated.tsv(a, :literal, :JSON)).sort.last
-  end
-
-  def test_inheritance
-    str = "string1"
-    annotation_str1 = "Annotation String 1"
-    annotation_str2 = "Annotation String 2"
-    AnnotatedString2.setup(str, annotation_str1, annotation_str2)
-    assert_equal annotation_str1, str.annotation_str
-    assert_equal annotation_str2, str.annotation_str2
-  end
-
-  def test_annotation_methods
-    str = "string"
-    annotation_str = "Annotation String"
-    AnnotatedString.setup(str, annotation_str)
-    assert_equal str + annotation_str, str.add_annot
-  end
-
-  def test_double_array_1
-    ary = ["string"]
-    annotation_str = "Annotation String"
-    ary.extend AnnotatedArray
-    ary_ary = [ary]
-    ary_ary.extend AnnotatedArray
-    AnnotatedString.setup(ary, annotation_str)
-    AnnotatedString.setup(ary_ary, annotation_str)
-    assert_equal [AnnotatedString], ary.annotation_types
-    assert_equal annotation_str, ary.annotation_str
-    assert_equal annotation_str, ary[0].annotation_str
-  end
-
-  def test_double_array_2
-    a = ["a"]
-    b = AnnotatedString.setup([AnnotatedString.setup(["a"])])
-    AnnotatedString.setup(a)
-    a.extend AnnotatedArray
-    assert AnnotatedString === b[0]
-    b.extend AnnotatedArray
-    assert AnnotatedString === b[0, true]
-    assert(!a.double_array)
-    assert(b.double_array)
-  end
-
-  def test_annotation_positional2hash
-    str = "string"
-    annotation_str = "Annotation String"
-    AnnotatedString.setup(str, :annotation_str => annotation_str)
-    assert_equal str + annotation_str, str.add_annot
-  end
-
-end

data/test/rbbt/test_association.rb

@@ -1,103 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
-require 'rbbt/util/tmpfile'
-require 'test/unit'
-
-require 'rbbt/workflow'
-require 'rbbt/entity'
-
-require 'rbbt/association'
-require 'rbbt/association/open'
-require 'rbbt/knowledge_base'
-require 'rbbt/entity'
-
-
-TEST_ASSOCIATIONS =<<-EOF
-#: :sep=" "#:namespace=Hsa/jan2013
-#Entity1 Entity2 Score Entity3 Gene
-a A 1 aa TP53
-b B 2 bb KRAS
-c C|K 3|4 cc|kk PTEN|PTEN
-EOF
-
-class TestAssociations < Test::Unit::TestCase
-  
-  FAssocs = ""
-  DAssocs = ""
-
-  def setup
-    FAssocs.replace TmpFile.tmp_file
-    DAssocs.replace TmpFile.tmp_file
-    Open.write(FAssocs, TEST_ASSOCIATIONS)
-  end
-
-  def teardown
-    FileUtils.rm FAssocs
-    FileUtils.rm_rf DAssocs
-  end
-
-  def test_simple_open
-    database = Association.open(FAssocs, {}, :dir => DAssocs)
-    database.unnamed = false
-    assert_equal ["C", "K"], database["c"]["Entity2"]
-  end
- 
-  def test_source_open
-    database = Association.open(FAssocs, {:source => "Entity2", :zipped => true}, :dir => DAssocs)
-    assert_equal ["c", "3", 'cc', "PTEN"], database["C"].flatten
-    assert_equal ["c", "4", 'kk', "PTEN"], database["K"].flatten
-  end
-  
-  def test_target_open
-    database = Association.open(FAssocs, {:source => "Entity2", :target => "Entity3", :zipped => true}, :dir => DAssocs)
-    assert_equal ["cc", "c", "3", "PTEN"], database["C"].flatten
-    assert_equal ["kk", "c", "4", "PTEN"], database["K"].flatten
-  end
-
-
-  def test_gene_open
-    database = Association.open(FAssocs, {:source => "Gene=~Associated Gene Name", :target => "Entity3", :zipped => true}, :dir => DAssocs)
-    assert_equal ["aa"], database["TP53"].first
-  end
-
-
-  def __test_ICGC
-    assoc = Association.open(Open.open('ftp://data.dcc.icgc.org/current/Chronic_Lymphocytic_Leukemia-ISC_MICINN-ES/simple_somatic_mutation.CLLE-ES.tsv.gz'),
-                         { :source => "gene_affected=~Ensembl Gene ID=>Associated Gene Name", :target => "icgc_donor_id=~Sample", 
-                           :fields => ['consequence_type'],  
-                           :namespace => 'Hsa/jan2013',
-                           :merge => true, :header_hash=>''}, :persist => false)
-
-    assert_equal 9, assoc["SF3B1"]["Sample"].uniq.length
-  end
-
-  def __test_target_open
-
-    database = Association.open(Pina.protein_protein,{ 
-                                :undirected => false, 
-                                :target => "Interactor UniProt/SwissProt Accession=~UniProt/SwissProt Accession"}, :persist => false)
-
-    assert( ! database["Q13547"][0].include?("O15379"))
-
-    database = Association.open(Pina.protein_protein,{
-                                :undirected => true, 
-                                :target => "Interactor UniProt/SwissProt Accession=~UniProt/SwissProt Accession"}, :persist => false)
-
-    assert database["O15379"][0].include? "Q13547"
-
-    assert database["Q13547"][0].include? "O15379"
-  end
-
-  def __test_gene_open_translate
-    tp53 = Gene.setup("TP53", "Associated Gene Name", "Hsa/jan2013")
-    database = Association.open(FAssocs, {:source => "Gene=~Associated Gene Name", :source_format => "Ensembl Gene ID", :target => "Entity3", :zipped => true}, :dir => DAssocs)
-    assert_equal ["aa"], database[tp53.ensembl].first
-  end
-
-  def __test_gene_target_open_translate
-    tp53 = Gene.setup("TP53", "Associated Gene Name", "Hsa/jan2013")
-    database = Association.open(FAssocs, {:target => "Gene=~Associated Gene Name=>Ensembl Gene ID", :source => "Entity3", :zipped => true}, :dir => DAssocs)
-    assert_equal [tp53.ensembl], database["aa"].first
-  end
-
-
-end

data/test/rbbt/test_entity.rb

@@ -1,252 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
-require 'rbbt'
-require 'rbbt/entity'
-require 'rbbt/util/tmpfile'
-require 'test/unit'
-
-class TestA
-  attr_accessor :foo, :bar
-  def initialize(foo, bar)
-    @foo = foo
-    @bar = bar
-  end
-end
-
-Entity.entity_property_cache = Rbbt.tmp.test.entity_property.find
-module ReversableString
-  extend Entity
-
-  self.annotation :foo, :bar
-
-  property :reverse_text_ary => :array do
-    $count += 1
-    self.collect{|s| s.reverse}
-  end
-
-  property :reverse_text_single => :single do
-    $count += 1
-    self.reverse
-  end
-
-  property :reverse_text_ary_p => :array2single do
-    $count += 1
-    self.collect{|s| s.reverse}
-  end
-
-  property :reverse_text_single_p => :single do
-    $count += 1
-    self.reverse
-  end
-
-  property :reverse_text_ary_p_array => :array do
-    $count += 1
-    self.collect{|s| s.reverse}
-  end
-
-  property :random => :single do
-    rand
-  end
-
-  property :annotation_list => :single do
-    self.chars.to_a.collect{|c| 
-      ReversableString.setup(c)
-    }
-  end
-
-  persist :reverse_text_ary_p, :marshal
-  #persist :reverse_text_single_p, :memory
-
-  persist :reverse_text_ary_p_array, :array, :dir => TmpFile.tmp_file
-
-  persist :annotation_list, :annotations, :dir => TmpFile.tmp_file
-
-
-  $processed_multiple = []
-  property :multiple_annotation_list => :multiple do |list|
-    $processed_multiple.concat list
-    res = {}
-    list.collect do |e|
-      e.chars.to_a.collect{|c| 
-        ReversableString.setup(c)
-      }
-    end
-  end
-
-  persist :multiple_annotation_list, :annotations, :dir => TmpFile.tmp_file
-  #persist :multiple_annotation_list, :annotations, :dir => Rbbt.tmp.test.annots
-end
-
-class TestEntity < Test::Unit::TestCase
-
-  def test_property_ary
-    a = ["String1", "String2"]
-    ReversableString.setup(a)
-
-    $count = 0
-
-    assert_equal "2gnirtS", a.reverse_text_ary.last
-    assert_equal 1, $count
-    a._ary_property_cache.clear
-    assert_equal "2gnirtS", a[1].reverse_text_ary
-    assert_equal 2, $count
-    a._ary_property_cache.clear
-
-    $count = 0
-    a.each do |string|
-      string.reverse_text_ary
-      assert_equal 1, $count
-    end
-  end
-
-  def test_property_single
-    a = ["String1", "String2"]
-    ReversableString.setup a
-
-    $count = 0
-
-    assert_equal "2gnirtS", a.reverse_text_single.last
-    assert_equal 2, $count
-    assert_equal "2gnirtS", a[1].reverse_text_single
-    assert_equal 3, $count
-  end
-
-  def test_property_ary_p
-    a = ["String1", "String2"]
-    ReversableString.setup a
-
-    a.reverse_text_ary_p
-
-    $count = 0
-
-    assert_equal "2gnirtS", a.reverse_text_ary_p.last
-    assert_equal "2gnirtS", a.collect{|e| e.reverse_text_ary_p }[1]
-    assert_equal 0, $count
-  end
-
-  def test_property_single_p
-    a = ["String1", "String2"]
-    ReversableString.setup a
-
-    $count = 0
-
-    assert_equal "2gnirtS", a.reverse_text_single_p.last
-
-    assert_equal 2, $count
-
-    a = ["String1", "String2"]
-    ReversableString.setup a
-
-    $count = 0
-
-    assert_equal "2gnirtS", a.reverse_text_single_p.last
-    assert_equal 2, $count
-    assert_equal "2gnirtS", a[1].reverse_text_single_p
-    assert_equal 3, $count
-  end
-
-  def test_property_ary_p_array
-    a = ["String1", "String2"]
-    ReversableString.setup a
-
-    assert_equal "2gnirtS", a.reverse_text_ary_p_array.last
-
-    $count = 0
-
-    assert_equal "2gnirtS", a.reverse_text_ary_p_array.last
-    assert_equal 0, $count
-    assert_equal "2gnirtS", a.reverse_text_ary_p_array.last
-    assert_equal 0, $count
-  end
-
-  def test_unpersist
-    a = ["String1", "String2"]
-    ReversableString.setup a
-
-    # Before persist
-    assert(! ReversableString.persisted?(:random))
-
-    r1 = a.random
-    r2 = a.random
-    assert_not_equal r1, r2
-
-    # After persist
-    ReversableString.persist :random
-    assert ReversableString.persisted?(:random)
-
-    r1 = a.random
-    r2 = a.random
-    assert_equal r1, r2
-
-    # After unpersist
-    ReversableString.unpersist :random
-    refute ReversableString.persisted?(:random)
-
-    r1 = a.random
-    r2 = a.random
-    assert_not_equal r1, r2
-
-  end
-
-  def test_persist_annotations
-    string = 'aaabbbccc'
-    ReversableString.setup(string)
-    assert_equal string.length, string.annotation_list.length
-    assert_equal string.length, string.annotation_list.length
-  end
-
-  def test_persist_multiple_annotations
-    string1 = 'aaabbbccc'
-    string2 = 'AAABBBCCC'
-    string3 = 'AAABBBCCC_3'
-    string4 = 'AAABBBCCC_4'
-
-
-    $processed_multiple = []
-
-    array = ReversableString.setup([string1, string2])
-    assert_equal [string1, string2].collect{|s| s.chars}, array.multiple_annotation_list
-    assert_equal string1.length, array[0].multiple_annotation_list.length
-    assert_equal $processed_multiple, [string1, string2]
-
-    array = ReversableString.setup([string2, string3])
-    assert_equal [string2, string3].collect{|s| s.chars}, array.multiple_annotation_list
-    assert_equal string3, array.multiple_annotation_list.last * ""
-    assert_equal $processed_multiple, [string1, string2, string3]
-
-    $processed_multiple = []
-    array = ReversableString.setup([string2, string3])
-    assert_equal [string2, string3].collect{|s| s.chars}, array.multiple_annotation_list
-    assert_equal string2.length, array[0].multiple_annotation_list.length
-    assert_equal $processed_multiple, []
-
-    $processed_multiple = []
-    array = ReversableString.setup([string2, string3, string4])
-    assert_equal string2.length, array.multiple_annotation_list[0].length
-    assert_equal $processed_multiple, [string4]
-
-    string1 = 'aaabbbccc'
-    string2 = 'AAABBBCCC'
-    string3 = 'AAABBBCCC_3'
-    string4 = 'AAABBBCCC_4'
-
-    $processed_multiple = []
-    array = ReversableString.setup([string2, string3, string4])
-    assert_equal string2.length, array[0].multiple_annotation_list.length
-    assert_equal $processed_multiple, []
-
-  end
-
-  def test_clean_annotations
-
-    string = "test_string"
-    ReversableString.setup string
-    assert string.respond_to?(:reverse_text_single)
-    assert ! string.clean_annotations.respond_to?(:reverse_text_single)
-
-  end
-
-  def test_all_properties
-    assert ReversableString.setup("TEST").all_properties.include?("reverse_text_ary")
-    assert_equal ReversableString.setup("TEST").all_properties, ReversableString.all_properties
-  end
-end

data/test/rbbt/test_fix_width_table.rb

@@ -1,135 +0,0 @@
-require File.join(File.expand_path(File.dirname(__FILE__)), '../', 'test_helper.rb')
-require 'rbbt/fix_width_table'
-require 'rbbt/tsv'
-require 'rbbt/tsv/manipulate'
-
-class TestFixWidthTable < Test::Unit::TestCase
-  def load_data(data)
-    tsv = TSV.open(data, :list, :sep=>":", :cast => proc{|e| e =~ /(\s*)(_*)/; ($1.length..($1.length + $2.length - 1))})
-    tsv.add_field "Start" do |key, values|
-      values["Range"].first
-    end
-    tsv.add_field "End" do |key, values|
-      values["Range"].last
-    end
-
-    tsv = tsv.slice ["Start", "End"]
- 
-    tsv
-  end
-
-  def test_options
-    TmpFile.with_file do |filename|
-      f = FixWidthTable.new filename, 100, true
-      f.close
-
-      f1 = FixWidthTable.new filename, 100, false
-
-      assert_equal true, f1.range
-    end
-  end
-
-  def test_add
-    TmpFile.with_file do |filename|
-      f = FixWidthTable.new filename, 100, true
-      f.add [1,2,0], "test1"
-      f.add [3,4,0], "test2"
-      f.read
-
-      assert_equal 1, f.idx_pos(0)
-      assert_equal 3, f.idx_pos(1)
-      assert_equal 2, f.idx_pos_end(0)
-      assert_equal 4, f.idx_pos_end(1)
-      assert_equal 0, f.idx_overlap(0)
-      assert_equal 0, f.idx_overlap(1)
-      assert_equal "test1", f.idx_value(0)
-      assert_equal "test2", f.idx_value(1)
-
-    end
- 
-  end
-
-  def test_point
-    data =<<-EOF
-#: :sep=/\\s+/#:type=:single#:cast=:to_i
-#ID Pos
-a 1
-b 10
-c 20
-d 12
-e 26
-f 11
-g 25
-    EOF
-    TmpFile.with_file(data) do |datafile|
-      tsv = TSV.open datafile
-      TmpFile.with_file do |filename|
-        f = FixWidthTable.new filename, 100, false
-        f.add_point tsv
-        f.read
-
-        assert_equal %w(), f[0].sort
-        assert_equal %w(b), f[10].sort
-        assert_equal %w(a b c d f), f[(0..20)].sort
-      end
-    end
-  end
-
-  def test_range
-    data =<<-EOF
-##012345678901234567890
-#ID:Range
-a:   ______
-b: ______
-c:    _______
-d:  ____
-e:    ______
-f:             ___
-g:         ____
-    EOF
-    TmpFile.with_file(data) do |datafile|
-      tsv = load_data(datafile)
-      TmpFile.with_file do |filename|
-        f = FixWidthTable.new filename, 100, true
-        f.add_range tsv
-        f.read
-
-        assert_equal %w(), f[0].sort
-        assert_equal %w(b), f[1].sort
-        assert_equal %w(), f[20].sort
-        assert_equal %w(), f[(20..100)].sort
-        assert_equal %w(a b d), f[3].sort
-        assert_equal %w(a b c d e), f[(3..4)].sort
-        assert_equal %w(a c e), f[7].sort
-      end
-    end
-  end
-
-
-  def test_range_pos
-    data =<<-EOF
-##012345678901234567890
-#ID:Range
-a:   ______
-b: ______
-c:    _______
-d:  ____
-e:    ______
-f:             ___
-g:         ____
-    EOF
-    TmpFile.with_file(data) do |datafile|
-      tsv = load_data(datafile)
-      TmpFile.with_file do |filename|
-        f = FixWidthTable.new filename, 100, true
-        f.add_range tsv
-        f.read
-
-        assert_equal %w(), f.overlaps(0).sort
-        assert_equal %w(1:6), f.overlaps(1).sort
-        assert_equal %w(1:6:b), f.overlaps(1, true).sort
-      end
-    end
-  end
-end
-