code_ruby/test/maasha/test_seq.rb

   1 #!/usr/bin/env ruby
   2
   3 require 'maasha/seq'
   4 require 'test/unit'
   5 require 'pp'
   6
   7 class TestSeq < Test::Unit::TestCase
   8   def setup
   9     @entry = Seq.new
  10   end
  11
  12   #  def test_Seq# autoremoves whitespace, newlines, and carriage returns
  13   #    dna = Seq.new
  14   #    dna.seq = "A\tT\r\tC\nG  "
  15   #    assert_equal(dna.seq, "ATCG")
  16   #  end
  17
  18   def test_Seq_is_dna_with_no_sequence_type_returns_false
  19     assert(@entry.is_dna? == false)
  20   end
  21
  22   def test_Seq_is_dna_with_dna_sequence_type_returns_true
  23     @entry.type = 'dna'
  24     assert(@entry.is_dna? == true)
  25   end
  26
  27   def test_Seq_is_rna_with_no_sequence_type_returns_false
  28     assert(@entry.is_rna? == false)
  29   end
  30
  31   def test_Seq_is_rna_with_rna_sequence_type_returns_true
  32     @entry.type = 'rna'
  33     assert(@entry.is_rna? == true)
  34   end
  35
  36   def test_Seq_is_protein_with_no_sequence_type_returns_false
  37     assert(@entry.is_protein? == false)
  38   end
  39
  40   def test_Seq_is_protein_with_protein_sequence_type_returns_true
  41     @entry.type = 'protein'
  42     assert_equal(true, @entry.is_protein?)
  43   end
  44
  45   def test_Seq_type_guess_without_sequence_raises
  46     assert_raise(SeqError) { @entry.type_guess }
  47   end
  48
  49   def test_Seq_type_guess_with_protein_returns_protein
  50     @entry.seq = 'atcatcrFgatcg'
  51     assert_equal('protein', @entry.type_guess)
  52   end
  53
  54   def test_Seq_type_guess_with_rna_returns_rna
  55     @entry.seq = 'atcatcrUgatcg'
  56     assert_equal('rna', @entry.type_guess)
  57   end
  58
  59   def test_Seq_type_guess_with_dna_returns_dna
  60     @entry.seq = 'atcatcgatcg'
  61     assert_equal('dna', @entry.type_guess)
  62   end
  63
  64   def test_Seq_type_guess_EM_without_sequence_raises
  65     assert_raise(SeqError) { @entry.type_guess! }
  66   end
  67
  68   def test_Seq_type_guess_EM_with_protein_returns_protein
  69     @entry.seq = 'atcatcrFgatcg'
  70     @entry.type_guess!
  71     assert_equal('protein', @entry.type)
  72   end
  73
  74   def test_Seq_type_guess_EM_with_rna_returns_rna
  75     @entry.seq = 'atcatcrUgatcg'
  76     @entry.type_guess!
  77     assert_equal('rna', @entry.type)
  78   end
  79
  80   def test_Seq_type_guess_EM_with_dna_returns_dna
  81     @entry.seq = 'atcatcgatcg'
  82     @entry.type_guess!
  83     assert_equal('dna', @entry.type)
  84   end
  85
  86   def test_Seq_length_is_correct
  87     @entry.seq = 'ATCG'
  88     assert_equal(4, @entry.length)
  89   end
  90
  91   def test_Seq_indels_is_correct
  92     @entry.seq = 'ATCG.-~_'
  93     assert_equal(4, @entry.indels)
  94   end
  95
  96   def test_Seq_to_rna_raises_if_no_sequence
  97     @entry.type = 'dna'
  98     assert_raise(SeqError) { @entry.to_rna }
  99   end
 100
 101   def test_Seq_to_rna_raises_on_bad_type
 102     @entry.seq  = 'ATCG'
 103     @entry.type = 'rna'
 104     assert_raise(SeqError) { @entry.to_rna }
 105   end
 106
 107   def test_Seq_to_rna_transcribes_correctly
 108     @entry.seq  = 'ATCGatcg'
 109     @entry.type = 'dna'
 110     assert_equal("AUCGaucg", @entry.to_rna)
 111   end
 112
 113   def test_Seq_to_rna_changes_entry_type_to_rna
 114     @entry.seq  = 'ATCGatcg'
 115     @entry.type = 'dna'
 116     @entry.to_rna
 117     assert_equal("rna", @entry.type)
 118   end
 119
 120   def test_Seq_to_dna_raises_if_no_sequence
 121     @entry.type = 'rna'
 122     assert_raise(SeqError) { @entry.to_dna }
 123   end
 124
 125   def test_Seq_to_dna_raises_on_bad_type
 126     @entry.seq  = 'AUCG'
 127     @entry.type = 'dna'
 128     assert_raise(SeqError) { @entry.to_dna }
 129   end
 130
 131   def test_Seq_to_dna_transcribes_correctly
 132     @entry.seq  = 'AUCGaucg'
 133     @entry.type = 'rna'
 134     assert_equal("ATCGatcg", @entry.to_dna)
 135   end
 136
 137   def test_Seq_to_dna_changes_entry_type_to_dna
 138     @entry.seq  = 'AUCGaucg'
 139     @entry.type = 'rna'
 140     @entry.to_dna
 141     assert_equal("dna", @entry.type)
 142   end
 143
 144   def test_Seq_to_bp_returns_correct_record
 145     @entry.seq_name = 'test'
 146     @entry.seq      = 'ATCG'
 147     assert_equal({:SEQ_NAME=>"test", :SEQ=>"ATCG", :SEQ_LEN=>4}, @entry.to_bp)
 148   end
 149
 150   def test_Seq_to_bp_raises_on_missing_seq_name
 151     @entry.seq = 'ATCG'
 152     assert_raise(SeqError) { @entry.to_bp }
 153   end
 154
 155   def test_Seq_to_bp_raises_on_missing_sequence
 156     @entry.seq_name = 'test'
 157     assert_raise(SeqError) { @entry.to_bp }
 158   end
 159
 160   def test_Seq_to_fasta_returns_correct_entry
 161     @entry.seq_name = 'test'
 162     @entry.seq      = 'ATCG'
 163     assert_equal(">test\nATCG\n", @entry.to_fasta)
 164   end
 165
 166   def test_Seq_to_fasta_wraps_correctly
 167     entry = Seq.new("test", "ATCG")
 168     assert_equal(">test\nAT\nCG\n", entry.to_fasta(2))
 169   end
 170
 171   def test_Seq_to_key_with_bad_residue_raises
 172     entry = Seq.new("test", "AUCG")
 173     assert_raise(SeqError) { entry.to_key }
 174   end
 175
 176   def test_Seq_to_key_returns_correctly
 177     entry = Seq.new("test", "ATCG")
 178     assert_equal(54, entry.to_key)
 179   end
 180
 181   def test_Seq_reverse_returns_correctly
 182     @entry.seq = "ATCG"
 183     assert_equal("GCTA", @entry.reverse)
 184   end
 185
 186   def test_Seq_complement_raises_if_no_sequence
 187     @entry.type = 'dna'
 188     assert_raise(SeqError) { @entry.complement }
 189   end
 190
 191   def test_Seq_complement_raises_on_bad_type
 192     @entry.seq  = 'ATCG'
 193     @entry.type = 'protein'
 194     assert_raise(SeqError) { @entry.complement }
 195   end
 196
 197   def test_Seq_complement_for_DNA_is_correct
 198     @entry.seq  = 'ATCGatcg'
 199     @entry.type = 'dna'
 200     assert_equal("TAGCtagc", @entry.complement)
 201   end
 202
 203   def test_Seq_complement_for_RNA_is_correct
 204     @entry.seq  = 'AUCGaucg'
 205     @entry.type = 'rna'
 206     assert_equal("UAGCuagc", @entry.complement)
 207   end
 208
 209   def test_Seq_reverse_complement_for_DNA_is_correct
 210     @entry.seq  = 'ATCGatcg'
 211     @entry.type = 'dna'
 212     assert_equal("cgatCGAT", @entry.reverse_complement)
 213   end
 214
 215   def test_Seq_reverse_complement_for_RNA_is_correct
 216     @entry.seq  = 'AUCGaucg'
 217     @entry.type = 'rna'
 218     assert_equal("cgauCGAU", @entry.reverse_complement)
 219   end
 220
 221   def test_Seq_generate_with_length_lt_1_raises
 222     assert_raise(SeqError) { @entry.generate(-10, "dna") }
 223     assert_raise(SeqError) { @entry.generate(0, "dna") }
 224   end
 225
 226   def test_Seq_generate_with_bad_type_raises
 227     assert_raise(SeqError) { @entry.generate(10, "foo") }
 228   end
 229
 230   def test_Seq_generate_with_ok_type_dont_raise
 231     %w[dna DNA rna RNA protein Protein].each do |type|
 232       assert_nothing_raised { @entry.generate(10, type) }
 233     end
 234   end
 235
 236   def test_Seq_subseq_with_start_lt_0_raises
 237     @entry.seq = "ATCG"
 238     assert_raise(SeqError) { @entry.subseq(-1, 1) }
 239   end
 240
 241   def test_Seq_subseq_with_length_lt_1_raises
 242     @entry.seq = "ATCG"
 243     assert_raise(SeqError) { @entry.subseq(0, 0) }
 244   end
 245
 246   def test_Seq_subseq_with_start_plus_length_gt_seq_raises
 247     @entry.seq = "ATCG"
 248     assert_raise(SeqError) { @entry.subseq(0, 5) }
 249   end
 250
 251   def test_Seq_subseq_returns_correct_sequence
 252     @entry.seq  = "ATCG"
 253     assert_equal("AT", @entry.subseq(0, 2).seq)
 254     assert_equal("CG", @entry.subseq(2, 2).seq)
 255   end
 256
 257   def test_Seq_subseq_without_len_returns_correct_sequence
 258     @entry.seq  = "ATCG"
 259     assert_equal("ATCG", @entry.subseq(0).seq)
 260     assert_equal("CG",   @entry.subseq(2).seq)
 261   end
 262
 263   def test_Seq_subseq_returns_correct_qual
 264     @entry.seq  = "ATCG"
 265     @entry.qual = "abcd"
 266     assert_equal("ab", @entry.subseq(0, 2).qual)
 267     assert_equal("cd", @entry.subseq(2, 2).qual)
 268   end
 269
 270   def test_Seq_subseq_without_len_returns_correct_qual
 271     @entry.seq  = "ATCG"
 272     @entry.qual = "abcd"
 273     assert_equal("abcd", @entry.subseq(0).qual)
 274     assert_equal("cd",   @entry.subseq(2).qual)
 275   end
 276
 277   def test_Seq_subseq_bang_with_start_lt_0_raises
 278     @entry.seq = "ATCG"
 279     assert_raise(SeqError) { @entry.subseq!(-1, 1) }
 280   end
 281
 282   def test_Seq_subseq_bang_with_length_lt_1_raises
 283     @entry.seq = "ATCG"
 284     assert_raise(SeqError) { @entry.subseq!(0, 0) }
 285   end
 286
 287   def test_Seq_subseq_bang_with_start_plus_length_gt_seq_raises
 288     @entry.seq = "ATCG"
 289     assert_raise(SeqError) { @entry.subseq!(0, 5) }
 290   end
 291
 292   def test_Seq_subseq_bang_returns_correct_sequence
 293     @entry.seq  = "ATCG"
 294     @entry.subseq!(0, 2)
 295     assert_equal("AT", @entry.seq)
 296     @entry.seq  = "ATCG"
 297     @entry.subseq!(2, 2)
 298     assert_equal("CG", @entry.seq)
 299   end
 300
 301   def test_Seq_subseq_bang_without_len_returns_correct_sequence
 302     @entry.seq  = "ATCG"
 303     @entry.subseq!(0)
 304     assert_equal("ATCG", @entry.seq)
 305     @entry.seq  = "ATCG"
 306     @entry.subseq!(2)
 307     assert_equal("CG", @entry.seq)
 308   end
 309
 310   def test_Seq_subseq_bang_with_pos_and_len_returns_correct_qual
 311     @entry.seq  = "ATCG"
 312     @entry.qual = "abcd"
 313     @entry.subseq!(0, 2)
 314     assert_equal("ab", @entry.qual)
 315     @entry.seq  = "ATCG"
 316     @entry.qual = "abcd"
 317     @entry.subseq!(2, 2)
 318     assert_equal("cd", @entry.qual)
 319   end
 320
 321   def test_Seq_subseq_bang_with_pos_returns_correct_qual
 322     @entry.seq  = "ATCG"
 323     @entry.qual = "abcd"
 324     @entry.subseq!(0)
 325     assert_equal("abcd", @entry.qual)
 326     @entry.seq  = "ATCG"
 327     @entry.qual = "abcd"
 328     @entry.subseq!(2)
 329     assert_equal("cd", @entry.qual)
 330   end
 331
 332   def test_Seq_subseq_rand_returns_correct_sequence
 333     @entry.seq  = "ATCG"
 334     assert_equal("ATCG", @entry.subseq_rand(4).seq)
 335   end
 336
 337   def test_Seq_composition_returns_correctly
 338     @entry.seq = "AAAATTTCCG"
 339     assert_equal(4, @entry.composition["A"])
 340     assert_equal(3, @entry.composition["T"])
 341     assert_equal(2, @entry.composition["C"])
 342     assert_equal(1, @entry.composition["G"])
 343     assert_equal(0, @entry.composition["X"])
 344   end
 345
 346   def test_Seq_homopol_max_returns_0_with_empty_sequence
 347     @entry.seq = ""
 348     assert_equal(0, @entry.homopol_max)
 349   end
 350
 351   def test_Seq_homopol_max_returns_0_with_nil_sequence
 352     @entry.seq = nil
 353     assert_equal(0, @entry.homopol_max)
 354   end
 355
 356   def test_Seq_homopol_max_returns_0_when_not_found
 357     @entry.seq = "AtTcCcGggGnnNnn"
 358     assert_equal(0, @entry.homopol_max(6))
 359   end
 360
 361   def test_Seq_homopol_max_returns_correctly
 362     @entry.seq = "AtTcCcGggGnnNnn"
 363     assert_equal(5, @entry.homopol_max(3))
 364   end
 365
 366   def test_Seq_hard_mask_returns_correctly
 367     @entry.seq = "--AAAANn"
 368     assert_equal(33.33, @entry.hard_mask)
 369   end
 370
 371   def test_Seq_soft_mask_returns_correctly
 372     @entry.seq = "--AAAa"
 373     assert_equal(25.00, @entry.soft_mask)
 374   end
 375 end
 376
 377
 378 __END__