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_is_dna_with_no_sequence_type_returns_false
19 assert(@entry.is_dna? == false)
22 def test_Seq_is_dna_with_dna_sequence_type_returns_true
24 assert(@entry.is_dna? == true)
27 def test_Seq_is_rna_with_no_sequence_type_returns_false
28 assert(@entry.is_rna? == false)
31 def test_Seq_is_rna_with_rna_sequence_type_returns_true
33 assert(@entry.is_rna? == true)
36 def test_Seq_is_protein_with_no_sequence_type_returns_false
37 assert(@entry.is_protein? == false)
40 def test_Seq_is_protein_with_protein_sequence_type_returns_true
41 @entry.type = 'protein'
42 assert(@entry.is_protein? == true)
45 def test_Seq_length_is_correct
47 assert_equal(4, @entry.length)
50 def test_Seq_indels_is_correct
51 @entry.seq = 'ATCG.-~_'
52 assert_equal(4, @entry.indels)
55 def test_Seq_to_rna_raises_if_no_sequence
57 assert_raise(SeqError) { @entry.to_rna }
60 def test_Seq_to_rna_raises_on_bad_type
63 assert_raise(SeqError) { @entry.to_rna }
66 def test_Seq_to_rna_transcribes_correctly
67 @entry.seq = 'ATCGatcg'
69 assert_equal("AUCGaucg", @entry.to_rna)
72 def test_Seq_to_rna_changes_entry_type_to_rna
73 @entry.seq = 'ATCGatcg'
76 assert_equal("rna", @entry.type)
79 def test_Seq_to_dna_raises_if_no_sequence
81 assert_raise(SeqError) { @entry.to_dna }
84 def test_Seq_to_dna_raises_on_bad_type
87 assert_raise(SeqError) { @entry.to_dna }
90 def test_Seq_to_dna_transcribes_correctly
91 @entry.seq = 'AUCGaucg'
93 assert_equal("ATCGatcg", @entry.to_dna)
96 def test_Seq_to_dna_changes_entry_type_to_dna
97 @entry.seq = 'AUCGaucg'
100 assert_equal("dna", @entry.type)
103 def test_Seq_to_bp_returns_correct_record
104 @entry.seq_name = 'test'
106 assert_equal({:SEQ_NAME=>"test", :SEQ=>"ATCG", :SEQ_LEN=>4}, @entry.to_bp)
109 def test_Seq_to_bp_raises_on_missing_seq_name
111 assert_raise(SeqError) { @entry.to_bp }
114 def test_Seq_to_bp_raises_on_missing_sequence
115 @entry.seq_name = 'test'
116 assert_raise(SeqError) { @entry.to_bp }
119 def test_Seq_to_fasta_returns_correct_entry
120 @entry.seq_name = 'test'
122 assert_equal(">test\nATCG\n", @entry.to_fasta)
125 def test_Seq_to_fasta_wraps_correctly
126 entry = Seq.new("test", "ATCG")
127 assert_equal(">test\nAT\nCG\n", entry.to_fasta(2))
130 def test_Seq_to_key_with_bad_residue_raises
131 entry = Seq.new("test", "AUCG")
132 assert_raise(SeqError) { entry.to_key }
135 def test_Seq_to_key_returns_correctly
136 entry = Seq.new("test", "ATCG")
137 assert_equal(54, entry.to_key)
140 def test_Seq_reverse_returns_correctly
142 assert_equal("GCTA", @entry.reverse)
145 def test_Seq_complement_raises_if_no_sequence
147 assert_raise(SeqError) { @entry.complement }
150 def test_Seq_complement_raises_on_bad_type
152 @entry.type = 'protein'
153 assert_raise(SeqError) { @entry.complement }
156 def test_Seq_complement_for_DNA_is_correct
157 @entry.seq = 'ATCGatcg'
159 assert_equal("TAGCtagc", @entry.complement)
162 def test_Seq_complement_for_RNA_is_correct
163 @entry.seq = 'AUCGaucg'
165 assert_equal("UAGCuagc", @entry.complement)
168 def test_Seq_reverse_complement_for_DNA_is_correct
169 @entry.seq = 'ATCGatcg'
171 assert_equal("cgatCGAT", @entry.reverse_complement)
174 def test_Seq_reverse_complement_for_RNA_is_correct
175 @entry.seq = 'AUCGaucg'
177 assert_equal("cgauCGAU", @entry.reverse_complement)
180 def test_Seq_generate_with_length_lt_1_raises
181 assert_raise(SeqError) { @entry.generate(-10, "dna") }
182 assert_raise(SeqError) { @entry.generate(0, "dna") }
185 def test_Seq_generate_with_bad_type_raises
186 assert_raise(SeqError) { @entry.generate(10, "foo") }
189 def test_Seq_generate_with_ok_type_dont_raise
190 %w[dna DNA rna RNA protein Protein].each do |type|
191 assert_nothing_raised { @entry.generate(10, type) }
195 def test_Seq_subseq_with_start_lt_0_raises
197 assert_raise(SeqError) { @entry.subseq(-1, 1) }
200 def test_Seq_subseq_with_length_lt_1_raises
202 assert_raise(SeqError) { @entry.subseq(0, 0) }
205 def test_Seq_subseq_with_start_plus_length_gt_seq_raises
207 assert_raise(SeqError) { @entry.subseq(0, 5) }
210 def test_Seq_subseq_returns_correct_sequence
212 assert_equal("AT", @entry.subseq(0, 2).seq)
213 assert_equal("CG", @entry.subseq(2, 2).seq)
216 def test_Seq_subseq_without_len_returns_correct_sequence
218 assert_equal("ATCG", @entry.subseq(0).seq)
219 assert_equal("CG", @entry.subseq(2).seq)
222 def test_Seq_subseq_returns_correct_qual
225 assert_equal("ab", @entry.subseq(0, 2).qual)
226 assert_equal("cd", @entry.subseq(2, 2).qual)
229 def test_Seq_subseq_without_len_returns_correct_qual
232 assert_equal("abcd", @entry.subseq(0).qual)
233 assert_equal("cd", @entry.subseq(2).qual)
236 def test_Seq_subseq_bang_with_start_lt_0_raises
238 assert_raise(SeqError) { @entry.subseq!(-1, 1) }
241 def test_Seq_subseq_bang_with_length_lt_1_raises
243 assert_raise(SeqError) { @entry.subseq!(0, 0) }
246 def test_Seq_subseq_bang_with_start_plus_length_gt_seq_raises
248 assert_raise(SeqError) { @entry.subseq!(0, 5) }
251 def test_Seq_subseq_bang_returns_correct_sequence
254 assert_equal("AT", @entry.seq)
257 assert_equal("CG", @entry.seq)
260 def test_Seq_subseq_bang_without_len_returns_correct_sequence
263 assert_equal("ATCG", @entry.seq)
266 assert_equal("CG", @entry.seq)
269 def test_Seq_subseq_bang_with_pos_and_len_returns_correct_qual
273 assert_equal("ab", @entry.qual)
277 assert_equal("cd", @entry.qual)
280 def test_Seq_subseq_bang_with_pos_returns_correct_qual
284 assert_equal("abcd", @entry.qual)
288 assert_equal("cd", @entry.qual)
291 def test_Seq_subseq_rand_returns_correct_sequence
293 assert_equal("ATCG", @entry.subseq_rand(4).seq)
296 def test_Seq_composition_returns_correctly
297 @entry.seq = "AAAATTTCCG"
298 assert_equal(4, @entry.composition["A"])
299 assert_equal(3, @entry.composition["T"])
300 assert_equal(2, @entry.composition["C"])
301 assert_equal(1, @entry.composition["G"])
302 assert_equal(0, @entry.composition["X"])
305 def test_Seq_homopol_max_returns_0_with_empty_sequence
307 assert_equal(0, @entry.homopol_max)
310 def test_Seq_homopol_max_returns_0_with_nil_sequence
312 assert_equal(0, @entry.homopol_max)
315 def test_Seq_homopol_max_returns_0_when_not_found
316 @entry.seq = "AtTcCcGggGnnNnn"
317 assert_equal(0, @entry.homopol_max(6))
320 def test_Seq_homopol_max_returns_correctly
321 @entry.seq = "AtTcCcGggGnnNnn"
322 assert_equal(5, @entry.homopol_max(3))
325 def test_Seq_hard_mask_returns_correctly
326 @entry.seq = "--AAAANn"
327 assert_equal(33.33, @entry.hard_mask)
330 def test_Seq_soft_mask_returns_correctly
331 @entry.seq = "--AAAa"
332 assert_equal(25.00, @entry.soft_mask)
335 # def test_Seq_adaptor_locate_right_with_bad_hamming_dist_raises
336 # flunk("adaptor location needs updating")
337 # @entry.seq = "ATCG"
338 # assert_raise(SeqError) { @entry.adaptor_locate_right("ATCG", -1) }
339 # assert_raise(SeqError) { @entry.adaptor_locate_right("ATCG", 101) }
342 # def test_Seq_adaptor_locate_right_with_ok_hamming_dist_dont_raise
343 # flunk("adaptor location needs updating")
344 # @entry.seq = "ATCG"
345 # assert_nothing_raised { @entry.adaptor_locate_right("ATCG", 0) }
346 # assert_nothing_raised { @entry.adaptor_locate_right("ATCG", 50.5) }
347 # assert_nothing_raised { @entry.adaptor_locate_right("ATCG", 100) }
350 # def test_Seq_adaptor_locate_right_returns_correctly
351 # flunk("adaptor location needs updating")
352 # @entry.seq = "nnnnncgat"
353 # assert_equal(-1, @entry.adaptor_locate_right("X"))
354 # assert_equal(8, @entry.adaptor_locate_right("TX"))
355 # assert_equal(7, @entry.adaptor_locate_right("ATX"))
356 # assert_equal(6, @entry.adaptor_locate_right("GATX"))
357 # assert_equal(5, @entry.adaptor_locate_right("CGATX"))
358 # assert_equal(0, @entry.adaptor_locate_right("NNNNNCGAT"))
361 # def test_Seq_adaptor_locate_right_with_hd_returns_correctly
362 # flunk("adaptor location needs updating")
363 # @entry.seq = "nnnnncgat"
364 # assert_equal(5, @entry.adaptor_locate_right("XGAT", 25))
365 # assert_equal(5, @entry.adaptor_locate_right("XXAT", 50))
368 # def test_Seq_adaptor_locate_left_with_bad_hamming_dist_raises
369 # flunk("adaptor location needs updating")
370 # @entry.seq = "ATCG"
371 # assert_raise(SeqError) { @entry.adaptor_locate_left("ATCG", -1) }
372 # assert_raise(SeqError) { @entry.adaptor_locate_left("ATCG", 101) }
375 # def test_Seq_adaptor_locate_left_with_ok_hamming_dist_dont_raise
376 # flunk("adaptor location needs updating")
377 # @entry.seq = "ATCG"
378 # assert_nothing_raised { @entry.adaptor_locate_left("ATCG", 0) }
379 # assert_nothing_raised { @entry.adaptor_locate_left("ATCG", 50.5) }
380 # assert_nothing_raised { @entry.adaptor_locate_left("ATCG", 100) }
383 # def test_Seq_adaptor_locate_left_returns_correctly
384 # flunk("adaptor location needs updating")
385 # @entry.seq = "cgatnnnnn"
386 # assert_equal(-1, @entry.adaptor_locate_left("X"))
387 # assert_equal(0, @entry.adaptor_locate_left("XC"))
388 # assert_equal(1, @entry.adaptor_locate_left("XCG"))
389 # assert_equal(2, @entry.adaptor_locate_left("XCGA"))
390 # assert_equal(3, @entry.adaptor_locate_left("XCGAT"))
391 # assert_equal(8, @entry.adaptor_locate_left("CGATNNNNN"))
394 # def test_Seq_adaptor_locate_left_with_hd_returns_correctly
395 # flunk("adaptor location needs updating")
396 # @entry.seq = "cgatnnnnn"
397 # assert_equal(3, @entry.adaptor_locate_left("XGAT", 25))
398 # assert_equal(3, @entry.adaptor_locate_left("XXAT", 50))
401 # def test_Seq_adaptor_clip_right_returns_correct_sequence
402 # flunk("adaptor location needs updating")
403 # @entry.seq = "nnnnncgat"
404 # @entry.adaptor_clip_right("cgat")
405 # assert_equal( "nnnnn", @entry.seq)
408 # def test_Seq_adaptor_clip_right_with_hd_returns_correct_sequence
409 # flunk("adaptor location needs updating")
410 # @entry.seq = "nnnnncgat"
411 # @entry.adaptor_clip_right("xgat", 25)
412 # assert_equal( "nnnnn", @entry.seq)
415 # def test_Seq_adaptor_clip_right_returns_correct_qual
416 # flunk("adaptor location needs updating")
417 # @entry.seq = "nnnnncgat"
418 # @entry.qual = "abcdefghi"
419 # @entry.adaptor_clip_right("cgat")
420 # assert_equal( "abcde", @entry.qual)
423 # def test_Seq_adaptor_clip_right_with_hd_returns_correct_qual
424 # flunk("adaptor location needs updating")
425 # @entry.seq = "nnnnncgat"
426 # @entry.qual = "abcdefghi"
427 # @entry.adaptor_clip_right("xgat", 25)
428 # assert_equal( "abcde", @entry.qual)
431 # def test_Seq_adaptor_clip_left_returns_correct_sequence
432 # flunk("adaptor location needs updating")
433 # @entry.seq = "cgatnnnnn"
434 # @entry.adaptor_clip_left("cgat")
435 # assert_equal( "nnnnn", @entry.seq)
438 # def test_Seq_adaptor_clip_left_with_hd_returns_correct_sequence
439 # flunk("adaptor location needs updating")
440 # @entry.seq = "cgatnnnnn"
441 # @entry.adaptor_clip_left("cgax", 25)
442 # assert_equal( "nnnnn", @entry.seq)
445 # def test_Seq_adaptor_clip_left_returns_correct_qual
446 # flunk("adaptor location needs updating")
447 # @entry.seq = "cgatnnnnn"
448 # @entry.qual = "abcdefghi"
449 # @entry.adaptor_clip_left("cgat")
450 # assert_equal( "efghi", @entry.qual)
453 # def test_Seq_adaptor_clip_left_with_len_returns_correct_qual
454 # flunk("adaptor location needs updating")
455 # @entry.seq = "cgatnnnnn"
456 # @entry.qual = "abcdefghi"
457 # @entry.adaptor_clip_left("cgax", 25)
458 # assert_equal( "efghi", @entry.qual)