bio 0.7.1 → 1.0.0

data/test/unit/bio/sequence/test_aa.rb

@@ -0,0 +1,102 @@
+#
+# = test/unit/bio/sequence/test_aa.rb - Unit test for Bio::Sequencce::AA
+#
+# Copyright::   Copyright (C) 2006 
+#               Mitsuteru C. Nakao <n@bioruby.org>
+# Lisence::     Ruby's
+#
+# $Id: test_aa.rb,v 1.1 2006/02/08 07:20:24 nakao Exp $
+#
+
+require 'pathname'
+libpath = Pathname.new(File.join(File.dirname(__FILE__), ['..'] * 4, 'lib')).cleanpath.to_s
+$:.unshift(libpath) unless $:.include?(libpath)
+
+require 'test/unit'
+require 'bio/sequence'
+require 'bio/sequence/aa'
+
+
+module Bio
+
+
+  class TestSequenceAANew < Test::Unit::TestCase
+    def test_new
+      str = "RRLEHTFVFL RNFSLMLLRY"
+      assert(Bio::Sequence::AA.new(str))
+    end
+
+    def test_new_t
+      str = "RRLEHTFVFLRNFSLMLLRY"
+      str_t = "RRLEHTFVFL\tRNFSLMLLRY"
+      assert_equal(str, Bio::Sequence::AA.new(str_t))
+    end
+
+    def test_new_n
+      str = "RRLEHTFVFLRNFSLMLLRY"
+      str_n = "RRLEHTFVFL\nRNFSLMLLRY"
+      assert_equal(str, Bio::Sequence::AA.new(str_n))
+    end
+
+    def test_new_r
+      str = "RRLEHTFVFLRNFSLMLLRY"
+      str_r = "RRLEHTFVFL\n\rRNFSLMLLRY"
+      assert_equal(str, Bio::Sequence::AA.new(str_r))
+    end
+
+  end
+
+  
+  class TestSequenceAA < Test::Unit::TestCase
+
+    def setup
+      str = "RRLEHTFVFLRNFSLMLLRY"
+      @obj = Bio::Sequence::AA.new(str)
+    end
+
+    def test_to_s
+      str = "RRLEHTFVFLRNFSLMLLRY"
+      assert_equal(str, @obj.to_s)
+    end
+
+    def test_molecular_weight
+      assert_in_delta(2612.105, @obj.molecular_weight, 1e-4)
+    end
+    
+    def test_to_re
+      re = /RRLEHTFVFLRNFSLMLLRY/
+      assert_equal(re, @obj.to_re)
+      @obj[1, 1] = 'B'
+      re = /R[DN]LEHTFVFLRNFSLMLLRY/
+      assert_equal(re, @obj.to_re)
+    end
+
+    def test_codes
+      ary = ["Arg", "Arg", "Leu", "Glu", "His", "Thr", "Phe", "Val", 
+             "Phe", "Leu", "Arg", "Asn", "Phe", "Ser", "Leu", "Met", 
+             "Leu", "Leu", "Arg", "Tyr"]
+      assert_equal(ary, @obj.codes)
+    end
+
+    def test_names
+      ary = ["arginine", "arginine", "leucine", "glutamic acid", 
+             "histidine", "threonine", "phenylalanine", "valine", 
+             "phenylalanine", "leucine", "arginine", "asparagine", 
+             "phenylalanine", "serine", "leucine", "methionine", 
+             "leucine", "leucine", "arginine", "tyrosine"]
+      assert_equal(ary, @obj.names)
+    end
+  end
+
+
+
+  require 'bio/sequence/aa'  
+
+  class TestSequenceAACompat < Test::Unit::TestCase
+    def test_aa_self_randomize
+      composition = Bio::Sequence::AA.new("WWDTGAK").composition
+      assert(Bio::Sequence::AA.randomize(composition))
+    end
+  end
+
+end

data/test/unit/bio/sequence/test_common.rb

@@ -0,0 +1,178 @@
+#
+# test/unit/bio/sequence/test_common.rb - Unit test for Bio::Sequencce::Common
+#
+#   Copyright (C) 2006 Mitsuteru C. Nakao <n@bioruby.org>
+#
+#  This library is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2 of the License, or (at your option) any later version.
+#
+#  This library is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with this library; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+#
+#  $Id: test_common.rb,v 1.2 2006/02/07 16:53:08 nakao Exp $
+#
+
+require 'pathname'
+libpath = Pathname.new(File.join(File.dirname(__FILE__), ['..'] * 4, 'lib')).cleanpath.to_s
+$:.unshift(libpath) unless $:.include?(libpath)
+
+require 'test/unit'
+require 'bio/sequence'
+require 'bio/sequence/common'
+
+module Bio
+
+  class TSequence < String
+    include Bio::Sequence::Common
+  end
+
+  class TestSequenceCommon < Test::Unit::TestCase
+
+    def setup
+      @obj  = TSequence.new('atgcatgcatgcatgcaaaa')
+    end
+
+    def test_to_s
+      assert_equal('atgcatgcatgcatgcaaaa', @obj.to_s)
+    end
+
+    def test_seq
+      str = "atgcatgcatgcatgcaaaa"
+      assert_equal(str, @obj.seq)
+    end
+
+
+    # <<(*arg)
+    def test_push
+      str = "atgcatgcatgcatgcaaaaA"
+      assert_equal(str, @obj << "A")
+    end
+
+    # +(*arg)
+    def test_sum 
+      str = "atgcatgcatgcatgcaaaaatgcatgcatgcatgcaaaa"
+      assert_equal(str, @obj + @obj)
+    end
+
+    # window_search(window_size, step_size = 1)
+    def test_window_search
+      @obj.window_search(4) do |subseq|
+        assert_equal(20, @obj.size)
+      end
+    end
+
+    #total(hash)
+    def test_total
+      hash = {'a' => 1, 'c' => 2, 'g' => 4, 't' => 3}
+      assert_equal(44.0, @obj.total(hash))
+    end
+
+    def test_composition
+      composition = {"a"=>8, "c"=>4, "g"=>4, "t"=>4}
+      assert_equal(composition, @obj.composition)
+    end
+    
+    def test_splicing
+      #(position)
+      assert_equal("atgcatgc", @obj.splicing("join(1..4, 13..16)"))
+    end
+  end
+
+
+  class TestSequenceCommonNormalize < Test::Unit::TestCase
+    def test_no_normalize
+      str = "atgcatgcatgcatgcaaaA"
+      obj = Bio::TSequence.new(str)
+      assert_equal("atgcatgcatgcatgcaaaA", obj)
+    end
+
+    def test_normalize_A
+      str = "atgcatgcatgcatgcaaaA"
+      seq = Bio::TSequence.new(str)
+      assert_equal("atgcatgcatgcatgcaaaA", seq)
+      obj = seq.normalize!
+      assert_equal("atgcatgcatgcatgcaaaA", obj)
+    end
+
+    def test_normalize_a
+      str = "atgcatgcatgcatgcaaa"
+      seq = Bio::TSequence.new(str)
+      assert_equal("atgcatgcatgcatgcaaa", seq)
+      obj = seq.normalize!
+      assert_equal("atgcatgcatgcatgcaaa", obj)
+    end
+  end 
+
+
+  class TestSequenceCommonRansomize < Test::Unit::TestCase
+
+    def test_self_randomize
+      # self.randomize(*arg, &block)
+    end
+
+    def test_randomize
+      #randomize(hash = nil)
+    end
+
+  end
+
+
+  class TestSequenceCommonSubseq < Test::Unit::TestCase
+    #def subseq(s = 1, e = self.length)
+
+    def test_to_s_returns_self_as_string
+      s = "abcefghijklmnop"
+      sequence = TSequence.new(s)
+      assert_equal(s, sequence.to_s, "wrong value")
+      assert_instance_of(String, sequence.to_s, "not a String")
+    end
+
+    def test_subseq_returns_RuntimeError_blank_sequence_default_end
+      sequence = TSequence.new("")
+      assert_raise(RuntimeError) { sequence.subseq(5) }
+    end
+
+    def test_subseq_returns_RuntimeError_start_less_than_one
+      sequence = TSequence.new("blahblah")
+      assert_raise(RuntimeError) { sequence.subseq(0) }
+    end
+
+    def test_subseq_returns_subsequence
+      sequence = TSequence.new("hahasubhehe")
+      assert_equal("sub", sequence.subseq(5,7))
+    end
+
+  end
+
+
+  # Test Sequence#window_wearch
+  class TestSequenceCommonWindowSearch < Test::Unit::TestCase
+    
+    def test_window_search_with_width_3_default_step_no_residual
+      sequence = TSequence.new("agtca")
+      windows = []
+      returned_value = sequence.window_search(3) { |window| windows << window }
+      assert_equal(["agt", "gtc", "tca"], windows, "windows wrong")
+      assert_equal("", returned_value, "returned value wrong")
+    end
+    
+    # added
+    def test_window_search_with_width_3_step_two_with_residual
+      sequence = TSequence.new("agtcat")
+      windows = []
+      returned_value = sequence.window_search(3, 2) { |window| windows << window }
+      assert_equal(["agt", "tca"], windows, "windows wrong")
+      assert_equal("t", returned_value, "returned value wrong")
+    end
+
+  end
+
+end

data/test/unit/bio/sequence/test_compat.rb

@@ -0,0 +1,82 @@
+#
+# test/unit/bio/sequence/test_compat.rb - Unit test for Bio::Sequencce::Compat
+#
+#   Copyright (C) 2006 Mitsuteru C. Nakao <n@bioruby.org>
+#
+#  This library is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2 of the License, or (at your option) any later version.
+#
+#  This library is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with this library; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+#
+#  $Id: test_compat.rb,v 1.1 2006/02/05 17:39:27 nakao Exp $
+#
+
+require 'pathname'
+libpath = Pathname.new(File.join(File.dirname(__FILE__), ['..'] * 4, 'lib')).cleanpath.to_s
+$:.unshift(libpath) unless $:.include?(libpath)
+
+require 'test/unit'
+require 'bio/sequence'
+require 'bio/sequence/compat'
+
+module Bio
+  
+  class TSequence < String
+    include Bio::Sequence::Common
+  end
+
+
+  class TestSequenceCompat < Test::Unit::TestCase
+
+    def setup
+      @obj  = TSequence.new('atgcatgcatgcatgcaaaa')
+    end
+
+    def test_to_s
+      str = 'atgcatgcatgcatgcaaaa'
+      assert_equal(str, @obj.to_s)
+    end
+  end
+
+
+  class TestSequenceCommonCompat < Test::Unit::TestCase
+
+    # Test Sequence#to_fasta    
+    def test_to_fasta
+      sequence = TSequence.new("agtc" * 10)
+      header = "the header"
+      str = ">the header\n" + ("agtc" * 5) + "\n" + ("agtc" * 5) + "\n"
+      assert_equal(str, sequence.to_fasta(header, 20))
+    end
+
+  end
+
+
+  require 'bio/sequence/na'
+
+  class TestSequenceNACompat < Test::Unit::TestCase
+    def test_na_self_randomize
+      composition = Bio::Sequence::NA.new("acgtacgt").composition
+      assert(Bio::Sequence::NA.randomize(composition))
+    end
+  end 
+
+  require 'bio/sequence/aa'  
+
+  class TestSequenceNACompat < Test::Unit::TestCase
+    def test_aa_self_randomize
+      composition = Bio::Sequence::AA.new("WWDTGAK").composition
+      assert(Bio::Sequence::AA.randomize(composition))
+    end
+  end
+
+end

data/test/unit/bio/sequence/test_na.rb

@@ -0,0 +1,242 @@
+#
+# = test/unit/bio/sequence/test_na.rb - Unit test for Bio::Sequencce::NA
+#
+# Copyright::   Copyright (C) 2006 
+#               Mitsuteru C. Nakao <n@bioruby.org>
+# Lisence::     Ruby's
+#
+# $Id: test_na.rb,v 1.1 2006/02/08 07:08:22 nakao Exp $
+#
+
+require 'pathname'
+libpath = Pathname.new(File.join(File.dirname(__FILE__), ['..'] * 4, 'lib')).cleanpath.to_s
+$:.unshift(libpath) unless $:.include?(libpath)
+
+require 'test/unit'
+require 'bio/sequence'
+require 'bio/sequence/na'  
+
+module Bio
+
+  class TestSequenceNANew < Test::Unit::TestCase
+    def test_new
+      str = 'atgcatgcatgcatgcaaaa'
+      assert(Bio::Sequence::NA.new(str))
+    end
+
+    def test_new_t
+      str = "atgcatgcatgcatgcaaaa"
+      str_t = "atgcatgcat\tgca\ttgcaaaa"
+      assert_equal(str, Bio::Sequence::NA.new(str_t))
+    end
+
+    def test_new_n
+      str = "atgcatgcatgcatgcaaaa"
+      str_n = "atgcatgcat\ngca\ntgcaaaa"
+      assert_equal(str, Bio::Sequence::NA.new(str_n))
+    end
+
+    def test_new_r
+      str = "atgcatgcatgcatgcaaaa"
+      str_r = "atgcatgcat\n\rgca\n\rtgcaaaa"
+      assert_equal(str, Bio::Sequence::NA.new(str_r))
+    end
+
+  end
+  
+  class TestSequenceNA < Test::Unit::TestCase
+
+    def setup
+      @obj = Bio::Sequence::NA.new('atgcatgcatgcatgcaaaa')
+    end
+
+    def test_splicing
+      #     'atgcatgcatgcatgcaaaa'
+      #      12345678901234567890
+      str = 'atgca  catgcatg'.gsub(' ','')
+      assert_equal(str, @obj.splicing("join(1..5,8..15)"))
+    end
+
+    def test_forward_complement
+      str       = 'atgcatgcatgcatgcaaaa'
+      str_fcomp = 'tacgtacgtacgtacgtttt'
+      fcomp = @obj.forward_complement
+      assert_equal(str_fcomp, @obj.forward_complement)
+      assert_equal(str, @obj)
+      assert_equal(str_fcomp, @obj.forward_complement!)
+      assert_equal(str_fcomp, @obj)
+    end
+
+    def test_reverse_complement
+      str       = 'atgcatgcatgcatgcaaaa'
+      str_rcomp = 'tacgtacgtacgtacgtttt'.reverse
+      rcomp = @obj.forward_complement
+      assert_equal(str_rcomp, @obj.reverse_complement)
+      assert_equal(str, @obj)
+      assert_equal(str_rcomp, @obj.reverse_complement!)
+      assert_equal(str_rcomp, @obj)
+    end
+
+    def test_complement
+      assert(@obj.complement)
+      assert(@obj.complement!)
+    end
+
+    def test_to_s
+      str = 'atgcatgcatgcatgcaaaa'
+      assert_equal(str, @obj.to_s)
+    end
+
+    def test_codon_usage
+      usage = {"cat"=>1, "caa"=>1, "tgc"=>1, "gca"=>1, "atg"=>2}
+      assert_equal(usage, @obj.codon_usage)
+    end
+
+    def test_gc_percent
+      assert_equal(40, @obj.gc_percent)
+      @obj[0, 1] = 'g'
+      assert_equal(45, @obj.gc_percent)
+    end
+
+    def test_iliegal_bases
+      @obj[0, 1] = 'n'
+      @obj[1, 1] = 'y'
+      assert_equal(['n', 'y'], @obj.illegal_bases)
+    end
+
+    def test_molecular_weight
+      assert_in_delta(6174.3974, @obj.molecular_weight, 1e-4)
+    end
+
+    def test_to_re
+      assert_equal(/atgcatgcatgcatgcaaaa/, @obj.to_re)
+      @obj[1,1] = 'n'
+      @obj[2,1] = 'r'
+      @obj[3,1] = 's'
+      @obj[4,1] = 'y'
+      @obj[5,1] = 'w'
+      assert_equal(/a[atgc][ag][gc][tc][at]gcatgcatgcaaaa/, @obj.to_re)
+    end
+
+    def test_names
+      ary = ["Adenine", "Thymine", "Guanine"]
+      assert_equal(ary , @obj.splice("1..3").names)
+    end
+
+    def test_dna
+      @obj[0,1] = 'u'
+      assert_equal('utgcatgcatgcatgcaaaa', @obj)
+      assert_equal('ttgcatgcatgcatgcaaaa', @obj.dna)
+    end
+
+    def test_dna!
+      @obj[0,1] = 'u'
+      assert_equal('utgcatgcatgcatgcaaaa', @obj)
+      @obj.dna!
+      assert_equal('ttgcatgcatgcatgcaaaa', @obj)
+    end
+
+    def test_rna
+      assert_equal('atgcatgcatgcatgcaaaa', @obj)
+      assert_equal('augcaugcaugcaugcaaaa', @obj.rna)
+    end
+
+    def test_rna!
+      assert_equal('atgcatgcatgcatgcaaaa', @obj)
+      @obj.rna!
+      assert_equal('augcaugcaugcaugcaaaa', @obj)
+    end
+
+  end
+
+  class TestSequenceNATranslation < Test::Unit::TestCase
+    def setup
+
+      str = "aaacccgggttttaa"
+      #      K>>P>>G>>F>>*>>
+      #       N>>P>>G>>F>>
+      #        T>>R>>V>>L>>
+      #         P>>G>>F>>*>>
+      #     "tttgggcccaaaatt"
+      #      <<F<<G<<P<<K<<L
+      #        <<G<<P<<N<<*
+      #       <<V<<R<<T<<K            
+      @obj = Bio::Sequence::NA.new(str)
+    end
+
+    def test_translate
+      assert_equal("KPGF*", @obj.translate)
+    end
+
+    def test_translate_1
+      assert_equal("KPGF*", @obj.translate(1))
+    end
+
+    def test_translate_2
+      assert_equal("NPGF", @obj.translate(2))
+    end
+
+    def test_translate_3
+      assert_equal("TRVL", @obj.translate(3))
+    end
+
+    def test_translate_4
+      assert_equal("LKPGF", @obj.translate(4))
+    end
+
+    def test_translate_5
+      assert_equal("*NPG", @obj.translate(5))
+    end
+
+    def test_translate_6
+      assert_equal("KTRV", @obj.translate(6))
+    end
+
+    def test_translate_7
+      assert_equal("KPGF*", @obj.translate(7))
+      assert_equal(@obj.translate, @obj.translate(7))
+    end
+
+    def test_translate_n1
+      assert_equal("LKPGF", @obj.translate(-1))
+      assert_equal(@obj.translate(4), @obj.translate(-1))
+    end
+
+    def test_translate_n2
+      assert_equal("*NPG", @obj.translate(-2))
+      assert_equal(@obj.translate(5), @obj.translate(-2))
+    end
+
+    def test_translate_n3
+      assert_equal("KTRV", @obj.translate(-3))
+      assert_equal(@obj.translate(6), @obj.translate(-3))
+    end
+
+    def test_translate_0
+      assert_equal("KPGF*", @obj.translate(0))
+      assert_equal(@obj.translate, @obj.translate(0))
+      assert_equal(@obj.translate(7), @obj.translate(0))
+    end
+
+    def test_translate_unknown_x
+      @obj[3, 1] = 'N'
+      assert_equal("KXGF*", @obj.translate)
+    end
+
+    def test_translate_unknown_o
+      @obj[3, 1] = 'N'
+      assert_equal("KOGF*", @obj.translate(1, 1, 'O'))
+    end
+
+    def test_translate_given_codon_table
+      @obj[0, 1] = 't'
+      @obj[1, 1] = 'g'
+      @obj[2, 1] = 'a'
+      seleno_ct = Bio::CodonTable.copy(1)
+      seleno_ct['tga']  = 'U'
+      assert_equal("UPGF*", @obj.translate(1, seleno_ct))
+    end
+
+  end
+
+end