7 class TestSeq < Test::Unit::TestCase
12 # def test_Seq# autoremoves whitespace, newlines, and carriage returns
14 # dna.seq = "A\tT\r\tC\nG "
15 # assert_equal(dna.seq, "ATCG")
18 def test_Seq_new_bp_returns_correctly
19 record = {:SEQ_NAME => "test", :SEQ => "ATCG", :SEQ_TYPE => "dna", :SCORES => "hhhh"}
20 seq = Seq.new_bp(record)
21 assert_equal("test", seq.seq_name)
22 assert_equal("ATCG", seq.seq)
23 assert_equal("dna", seq.type)
24 assert_equal("hhhh", seq.qual)
27 def test_Seq_is_dna_with_no_sequence_type_returns_false
28 assert(@entry.is_dna? == false)
31 def test_Seq_is_dna_with_dna_sequence_type_returns_true
33 assert(@entry.is_dna? == true)
36 def test_Seq_is_rna_with_no_sequence_type_returns_false
37 assert(@entry.is_rna? == false)
40 def test_Seq_is_rna_with_rna_sequence_type_returns_true
42 assert(@entry.is_rna? == true)
45 def test_Seq_is_protein_with_no_sequence_type_returns_false
46 assert(@entry.is_protein? == false)
49 def test_Seq_is_protein_with_protein_sequence_type_returns_true
50 @entry.type = 'protein'
51 assert_equal(true, @entry.is_protein?)
54 def test_Seq_type_guess_without_sequence_raises
55 assert_raise(SeqError) { @entry.type_guess }
58 def test_Seq_type_guess_with_protein_returns_protein
59 @entry.seq = 'atcatcrFgatcg'
60 assert_equal('protein', @entry.type_guess)
63 def test_Seq_type_guess_with_rna_returns_rna
64 @entry.seq = 'atcatcrUgatcg'
65 assert_equal('rna', @entry.type_guess)
68 def test_Seq_type_guess_with_dna_returns_dna
69 @entry.seq = 'atcatcgatcg'
70 assert_equal('dna', @entry.type_guess)
73 def test_Seq_type_guess_EM_without_sequence_raises
74 assert_raise(SeqError) { @entry.type_guess! }
77 def test_Seq_type_guess_EM_with_protein_returns_protein
78 @entry.seq = 'atcatcrFgatcg'
80 assert_equal('protein', @entry.type)
83 def test_Seq_type_guess_EM_with_rna_returns_rna
84 @entry.seq = 'atcatcrUgatcg'
86 assert_equal('rna', @entry.type)
89 def test_Seq_type_guess_EM_with_dna_returns_dna
90 @entry.seq = 'atcatcgatcg'
92 assert_equal('dna', @entry.type)
95 def test_Seq_length_is_correct
97 assert_equal(4, @entry.length)
100 def test_Seq_indels_is_correct
101 @entry.seq = 'ATCG.-~_'
102 assert_equal(4, @entry.indels)
105 def test_Seq_to_rna_raises_if_no_sequence
107 assert_raise(SeqError) { @entry.to_rna }
110 def test_Seq_to_rna_raises_on_bad_type
113 assert_raise(SeqError) { @entry.to_rna }
116 def test_Seq_to_rna_transcribes_correctly
117 @entry.seq = 'ATCGatcg'
119 assert_equal("AUCGaucg", @entry.to_rna)
122 def test_Seq_to_rna_changes_entry_type_to_rna
123 @entry.seq = 'ATCGatcg'
126 assert_equal("rna", @entry.type)
129 def test_Seq_to_dna_raises_if_no_sequence
131 assert_raise(SeqError) { @entry.to_dna }
134 def test_Seq_to_dna_raises_on_bad_type
137 assert_raise(SeqError) { @entry.to_dna }
140 def test_Seq_to_dna_transcribes_correctly
141 @entry.seq = 'AUCGaucg'
143 assert_equal("ATCGatcg", @entry.to_dna)
146 def test_Seq_to_dna_changes_entry_type_to_dna
147 @entry.seq = 'AUCGaucg'
150 assert_equal("dna", @entry.type)
153 def test_Seq_to_bp_returns_correct_record
154 @entry.seq_name = 'test'
156 assert_equal({:SEQ_NAME=>"test", :SEQ=>"ATCG", :SEQ_LEN=>4}, @entry.to_bp)
159 def test_Seq_to_bp_raises_on_missing_seq_name
161 assert_raise(SeqError) { @entry.to_bp }
164 def test_Seq_to_bp_raises_on_missing_sequence
165 @entry.seq_name = 'test'
166 assert_raise(SeqError) { @entry.to_bp }
169 def test_Seq_to_fasta_returns_correct_entry
170 @entry.seq_name = 'test'
172 assert_equal(">test\nATCG\n", @entry.to_fasta)
175 def test_Seq_to_fasta_wraps_correctly
176 entry = Seq.new("test", "ATCG")
177 assert_equal(">test\nAT\nCG\n", entry.to_fasta(2))
180 def test_Seq_to_fastq_returns_correct_entry
181 @entry.seq_name = 'test'
184 assert_equal("@test\nATCG\n+\nhhhh\n", @entry.to_fastq)
187 def test_Seq_to_key_with_bad_residue_raises
188 entry = Seq.new("test", "AUCG")
189 assert_raise(SeqError) { entry.to_key }
192 def test_Seq_to_key_returns_correctly
193 entry = Seq.new("test", "ATCG")
194 assert_equal(54, entry.to_key)
197 def test_Seq_reverse_returns_correctly
199 assert_equal("GCTA", @entry.reverse.seq)
202 def test_Seq_complement_raises_if_no_sequence
204 assert_raise(SeqError) { @entry.complement }
207 def test_Seq_complement_raises_on_bad_type
209 @entry.type = 'protein'
210 assert_raise(SeqError) { @entry.complement }
213 def test_Seq_complement_for_DNA_is_correct
214 @entry.seq = 'ATCGatcg'
216 assert_equal("TAGCtagc", @entry.complement)
219 def test_Seq_complement_for_RNA_is_correct
220 @entry.seq = 'AUCGaucg'
222 assert_equal("UAGCuagc", @entry.complement)
225 def test_Seq_reverse_complement_for_DNA_is_correct
226 @entry.seq = 'ATCGatcg'
228 assert_equal("cgatCGAT", @entry.reverse_complement.seq)
231 def test_Seq_reverse_complement_for_RNA_is_correct
232 @entry.seq = 'AUCGaucg'
234 assert_equal("cgauCGAU", @entry.reverse_complement.seq)
237 def test_Seq_hamming_distance_returns_correctly
238 seq1 = Seq.new("test1", "ATCG")
239 seq2 = Seq.new("test2", "atgg")
240 assert_equal(1, seq1.hamming_distance(seq2))
243 def test_Seq_generate_with_length_lt_1_raises
244 assert_raise(SeqError) { @entry.generate(-10, "dna") }
245 assert_raise(SeqError) { @entry.generate(0, "dna") }
248 def test_Seq_generate_with_bad_type_raises
249 assert_raise(SeqError) { @entry.generate(10, "foo") }
252 def test_Seq_generate_with_ok_type_dont_raise
253 %w[dna DNA rna RNA protein Protein].each do |type|
254 assert_nothing_raised { @entry.generate(10, type) }
258 def test_Seq_subseq_with_start_lt_0_raises
260 assert_raise(SeqError) { @entry.subseq(-1, 1) }
263 def test_Seq_subseq_with_length_lt_1_raises
265 assert_raise(SeqError) { @entry.subseq(0, 0) }
268 def test_Seq_subseq_with_start_plus_length_gt_seq_raises
270 assert_raise(SeqError) { @entry.subseq(0, 5) }
273 def test_Seq_subseq_returns_correct_sequence
275 assert_equal("AT", @entry.subseq(0, 2).seq)
276 assert_equal("CG", @entry.subseq(2, 2).seq)
279 def test_Seq_subseq_without_len_returns_correct_sequence
281 assert_equal("ATCG", @entry.subseq(0).seq)
282 assert_equal("CG", @entry.subseq(2).seq)
285 def test_Seq_subseq_returns_correct_qual
288 assert_equal("ab", @entry.subseq(0, 2).qual)
289 assert_equal("cd", @entry.subseq(2, 2).qual)
292 def test_Seq_subseq_without_len_returns_correct_qual
295 assert_equal("abcd", @entry.subseq(0).qual)
296 assert_equal("cd", @entry.subseq(2).qual)
299 def test_Seq_subseq_bang_with_start_lt_0_raises
301 assert_raise(SeqError) { @entry.subseq!(-1, 1) }
304 def test_Seq_subseq_bang_with_length_lt_1_raises
306 assert_raise(SeqError) { @entry.subseq!(0, 0) }
309 def test_Seq_subseq_bang_with_start_plus_length_gt_seq_raises
311 assert_raise(SeqError) { @entry.subseq!(0, 5) }
314 def test_Seq_subseq_bang_returns_correct_sequence
317 assert_equal("AT", @entry.seq)
320 assert_equal("CG", @entry.seq)
323 def test_Seq_subseq_bang_without_len_returns_correct_sequence
326 assert_equal("ATCG", @entry.seq)
329 assert_equal("CG", @entry.seq)
332 def test_Seq_subseq_bang_with_pos_and_len_returns_correct_qual
336 assert_equal("ab", @entry.qual)
340 assert_equal("cd", @entry.qual)
343 def test_Seq_subseq_bang_with_pos_returns_correct_qual
347 assert_equal("abcd", @entry.qual)
351 assert_equal("cd", @entry.qual)
354 def test_Seq_subseq_rand_returns_correct_sequence
356 assert_equal("ATCG", @entry.subseq_rand(4).seq)
359 def test_Seq_composition_returns_correctly
360 @entry.seq = "AAAATTTCCG"
361 assert_equal(4, @entry.composition["A"])
362 assert_equal(3, @entry.composition["T"])
363 assert_equal(2, @entry.composition["C"])
364 assert_equal(1, @entry.composition["G"])
365 assert_equal(0, @entry.composition["X"])
368 def test_Seq_homopol_max_returns_0_with_empty_sequence
370 assert_equal(0, @entry.homopol_max)
373 def test_Seq_homopol_max_returns_0_with_nil_sequence
375 assert_equal(0, @entry.homopol_max)
378 def test_Seq_homopol_max_returns_0_when_not_found
379 @entry.seq = "AtTcCcGggGnnNnn"
380 assert_equal(0, @entry.homopol_max(6))
383 def test_Seq_homopol_max_returns_correctly
384 @entry.seq = "AtTcCcGggGnnNnn"
385 assert_equal(5, @entry.homopol_max(3))
388 def test_Seq_hard_mask_returns_correctly
389 @entry.seq = "--AAAANn"
390 assert_equal(33.33, @entry.hard_mask)
393 def test_Seq_soft_mask_returns_correctly
394 @entry.seq = "--AAAa"
395 assert_equal(25.00, @entry.soft_mask)