cleanded up test_seq.rb

git-svn-id: http://biopieces.googlecode.com/svn/trunk@548 74ccb610-7750-0410-82ae-013aeee3265d

diff --git a/code_ruby/Maasha/test/test_seq.rb b/code_ruby/Maasha/test/test_seq.rb
index 95b25a92fb2f2a1e764a373d5d9d5a4fbe4ae404..afda8ab7b1d7292c33babf1671e550ddde36184d 100755 (executable)
--- a/code_ruby/Maasha/test/test_seq.rb
+++ b/code_ruby/Maasha/test/test_seq.rb
@@ -4,217 +4,257 @@ require 'Maasha/lib/seq'
 require 'test/unit'
 
 class TestSeq < Test::Unit::TestCase 
+
+       # Testing Seq#initialize
+
        def test_Seq_initialize_with_0_args
-               my_seq = Seq.new
-               assert_equal( nil, my_seq.seq ) 
-               assert_equal( nil, my_seq.seq_type ) 
+               s = Seq.new
+               assert_equal( "", s.seq ) 
+               assert_equal( nil, s.seq_type ) 
        end
 
        def test_Seq_initialize_with_1_args
-               my_seq = Seq.new( "ATCG" )
-               assert_equal( "ATCG", my_seq.seq ) 
-               assert_equal( nil,    my_seq.seq_type )
+               s = Seq.new( "ATCG" )
+               assert_equal( "ATCG", s.seq ) 
+               assert_equal( nil,    s.seq_type )
        end
 
        def test_Seq_initialize_with_2_args
-               my_seq = Seq.new( "ATCG", "DNA" )
-               assert_equal( "ATCG", my_seq.seq ) 
-               assert_equal( "DNA", my_seq.seq_type ) 
+               s = Seq.new( "ATCG", "DNA" )
+               assert_equal( "ATCG", s.seq ) 
+               assert_equal( "DNA", s.seq_type ) 
        end 
 
-       def test_seq_type_guess_DNA
-               my_seq = Seq.new
+       # Testing Seq#seq_type_guess
 
-               my_seq.seq   = "ATCG"
-               assert_equal( "DNA", my_seq.seq_type_guess )
-               assert_equal( nil, my_seq.seq_type )
+       def test_seq_type_guess_DNA_uppercase
+               s = Seq.new( "ATCG" )
 
-               my_seq.seq   = "atcg"
-               assert_equal( "DNA", my_seq.seq_type_guess )
-               assert_equal( nil, my_seq.seq_type )
+               assert_equal( "DNA", s.seq_type_guess )
        end
 
-       def test_seq_type_guess_RNA
-               my_seq = Seq.new
+       def test_seq_type_guess_DNA_lowercase
+               s = Seq.new( "atcg" )
 
-               my_seq.seq   = "AUCG"
-               assert_equal( "RNA", my_seq.seq_type_guess )
-               assert_equal( nil, my_seq.seq_type )
+               assert_equal( "DNA", s.seq_type_guess )
+       end
 
-               my_seq.seq   = "aucg"
-               assert_equal( "RNA", my_seq.seq_type_guess )
-               assert_equal( nil, my_seq.seq_type )
+       def test_seq_type_guess_RNA_uppercase
+               s = Seq.new( "AUCG" )
+               assert_equal( "RNA", s.seq_type_guess )
        end
 
-       def test_seq_type_guess_AA
-               my_seq = Seq.new
+       def test_seq_type_guess_RNA_lowercase
+               s = Seq.new( "aucg" )
+               assert_equal( "RNA", s.seq_type_guess )
+       end
 
-               my_seq.seq   = "SEQ"
-               assert_equal( "AA", my_seq.seq_type_guess )
-               assert_equal( nil, my_seq.seq_type )
+       def test_seq_type_guess_AA_uppercase
+               s = Seq.new( "SEQ" )
+               assert_equal( "AA", s.seq_type_guess )
+       end
 
-               my_seq.seq   = "seq"
-               assert_equal( "AA", my_seq.seq_type_guess )
-               assert_equal( nil, my_seq.seq_type )
+       def test_seq_type_guess_AA_lowercase
+               s = Seq.new( "seq" )
+               assert_equal( "AA", s.seq_type_guess )
+               assert_equal( nil, s.seq_type )
        end
 
-       def test_seq_type_guess_DNA!
-               my_seq = Seq.new
+       def test_seq_type_guess_dont_change_instance_var
+               s = Seq.new( "seq" )
+               s.seq_type_guess
+               assert_equal( nil, s.seq_type )
+       end
 
-               my_seq.seq   = "ATCG"
-               assert_equal( "DNA", my_seq.seq_type_guess! )
-               assert_equal( "DNA", my_seq.seq_type )
+       # Testing Seq#seq_type_guess!
 
-               my_seq.seq   = "atcg"
-               assert_equal( "DNA", my_seq.seq_type_guess! )
-               assert_equal( "DNA", my_seq.seq_type )
+       def test_seq_type_guess_DNA_uppercase!
+               s = Seq.new( "ATCG" )
+               s.seq_type_guess!
+               assert_equal( "DNA", s.seq_type )
        end
 
-       def test_seq_type_guess_RNA!
-               my_seq = Seq.new
-
-               my_seq.seq   = "AUCG"
-               assert_equal( "RNA", my_seq.seq_type_guess! )
-               assert_equal( "RNA", my_seq.seq_type )
+       def test_seq_type_guess_DNA_lowercase!
+               s = Seq.new( "atcg" )
+               s.seq_type_guess!
+               assert_equal( "DNA", s.seq_type )
+       end
 
-               my_seq.seq   = "aucg"
-               assert_equal( "RNA", my_seq.seq_type_guess! )
-               assert_equal( "RNA", my_seq.seq_type )
+       def test_seq_type_guess_RNA_uppercase!
+               s = Seq.new( "AUCG" )
+               s.seq_type_guess!
+               assert_equal( "RNA", s.seq_type )
        end
 
-       def test_seq_type_guess_AA!
-               my_seq = Seq.new
+       def test_seq_type_guess_RNA_lowercase!
+               s = Seq.new( "aucg" )
+               s.seq_type_guess!
+               assert_equal( "RNA", s.seq_type )
+       end
 
-               my_seq.seq   = "SEQ"
-               assert_equal( "AA", my_seq.seq_type_guess! )
-               assert_equal( "AA", my_seq.seq_type )
+       def test_seq_type_guess_AA_uppercase!
+               s = Seq.new( "SEQ" )
+               s.seq_type_guess!
+               assert_equal( "AA", s.seq_type )
+       end
 
-               my_seq.seq   = "seq"
-               assert_equal( "AA", my_seq.seq_type_guess! )
-               assert_equal( "AA", my_seq.seq_type )
+       def test_seq_type_guess_AA_lowercase!
+               s = Seq.new( "seq" )
+               s.seq_type_guess!
+               assert_equal( "AA", s.seq_type )
        end
 
+       # Testing Seq#seq_alph
+
        def test_seq_alph_DNA
-               my_seq = Seq.new
+               s = Seq.new
 
-               assert_equal( %w{ A T C G }, my_seq.seq_alph( "DNA" ) )
-               assert_equal( %w{ A T C G }, my_seq.seq_alph( "dna" ) )
+               assert_equal( %w{ A T C G }, s.seq_alph( "DNA" ) )
+               assert_equal( %w{ A T C G }, s.seq_alph( "dna" ) )
        end
 
        def test_seq_alph_RNA
-               my_seq = Seq.new
+               s = Seq.new
 
-               assert_equal( %w{ A U C G }, my_seq.seq_alph( "RNA" ) )
-               assert_equal( %w{ A U C G }, my_seq.seq_alph( "rna" ) )
+               assert_equal( %w{ A U C G }, s.seq_alph( "RNA" ) )
+               assert_equal( %w{ A U C G }, s.seq_alph( "rna" ) )
        end
 
        def test_seq_alph_AA
-               my_seq = Seq.new
+               s = Seq.new
 
-               assert_equal( %w{ F L S Y C W P H Q R I M T N K V A D E G }, my_seq.seq_alph( "AA" ) )
-               assert_equal( %w{ F L S Y C W P H Q R I M T N K V A D E G }, my_seq.seq_alph( "aa" ) )
+               assert_equal( %w{ F L S Y C W P H Q R I M T N K V A D E G }, s.seq_alph( "AA" ) )
+               assert_equal( %w{ F L S Y C W P H Q R I M T N K V A D E G }, s.seq_alph( "aa" ) )
        end
 
        def test_seq_alph_invalid
-               my_seq = Seq.new
+               s = Seq.new
 
-               assert_raise( RuntimeError ) { my_seq.seq_alph( "protein" )}
+               assert_raise( RuntimeError ) { s.seq_alph( "protein" )}
        end
 
+       # Testing Seq#wrap
+
        def test_wrap_arg_is_a_number
-               my_seq = Seq.new
+               s = Seq.new
 
-               assert_raise( RuntimeError ) { my_seq.wrap( "FOO" ) }
+               assert_raise( RuntimeError ) { s.wrap( "FOO" ) }
        end
 
        def test_wrap_arg_is_a_positive_number
-               my_seq = Seq.new
+               s = Seq.new
 
-               assert_raise( RuntimeError ) { my_seq.wrap( 0 ) }
-               assert_raise( RuntimeError ) { my_seq.wrap( -10 ) }
+               assert_raise( RuntimeError ) { s.wrap( 0 ) }
+               assert_raise( RuntimeError ) { s.wrap( -10 ) }
        end
 
        def test_wrap_with_0_args
-               my_seq = Seq.new( "ACTGACTAGCATCGACTACGACTGACACGACGACGACGACCGAACGATCGATCGCAGACGACGCAGCATGACGACGTACGACTACGACT" )
+               s = Seq.new( "ACTGACTAGCATCGACTACGACTGACACGACGACGACGACCGAACGATCGATCGCAGACGACGCAGCATGACGACGTACGACTACGACT" )
 
-               assert_equal( "ACTGACTAGCATCGACTACGACTGACACGACGACGACGACCGAACGATCGATCGCAGACGACGCAGCATGACGACGTACG\nACTACGACT", my_seq.wrap )
+               assert_equal( "ACTGACTAGCATCGACTACGACTGACACGACGACGACGACCGAACGATCGATCGCAGACGACGCAGCATGACGACGTACG\nACTACGACT", s.wrap )
        end
 
        def test_wrap_with_1_args
-               my_seq = Seq.new( "ACTGACTAGCATCGACTACGACTGACACGACGACGACGACCGAACGATCGATCGCAGACGACGCAGCATGACGACGTACGACTACGACT" )
+               s = Seq.new( "ATCG" )
 
-               assert_equal( "ACTGACTAGCATCGACTACGACTGACACGACGACGACGAC\nCGAACGATCGATCGCAGACGACGCAGCATGACGACGTACG\nACTACGACT", my_seq.wrap( 40 ) )
+               assert_equal( "AT\nCG", s.wrap( 2 ) )
        end
 
        def test_wrap_with_2_args
-               my_seq = Seq.new( "ACTGACTAGCATCGACTACGACTGACACGACGACGACGACCGAACGATCGATCGCAGACGACGCAGCATGACGACGTACGACTACGACT" )
-
-               assert_equal( "ACTGACTAGCATCGACTACGACTGACACGACGACGACGAC\rCGAACGATCGATCGCAGACGACGCAGCATGACGACGTACG\rACTACGACT", my_seq.wrap( 40, "\r" ) )
+               s = Seq.new( "ATCG" )
 
-               assert_equal( "ACTGACTAGCATCGACTACGACTGACACGACGACGACGACCGAACGATCGATCGCAGACGACGCAGCATGACGACGTACGACTACGACT", my_seq.seq )
+               assert_equal( "AT\rCG", s.wrap( 2, "\r" ) )
        end
 
        def test_wrap_dont_change_instance_var
-               my_seq = Seq.new( "ACTGACTAGCATCGACTACGACTGACACGACGACGACGACCGAACGATCGATCGCAGACGACGCAGCATGACGACGTACGACTACGACT" )
+               s = Seq.new( "ATCG" )
 
-               my_seq.wrap
+               s.wrap( 2 )
 
-               assert_equal( "ACTGACTAGCATCGACTACGACTGACACGACGACGACGACCGAACGATCGATCGCAGACGACGCAGCATGACGACGTACGACTACGACT", my_seq.seq )
+               assert_equal( "ATCG", s.seq )
        end
 
+       # Testing Seq#wrap!
+
        def test_wrap_with_0_args!
-               my_seq = Seq.new( "ACTGACTAGCATCGACTACGACTGACACGACGACGACGACCGAACGATCGATCGCAGACGACGCAGCATGACGACGTACGACTACGACT" )
+               s = Seq.new( "ACTGACTAGCATCGACTACGACTGACACGACGACGACGACCGAACGATCGATCGCAGACGACGCAGCATGACGACGTACGACTACGACT" )
+
+               s.wrap!
 
-               my_seq.wrap!
+               assert_equal( "ACTGACTAGCATCGACTACGACTGACACGACGACGACGACCGAACGATCGATCGCAGACGACGCAGCATGACGACGTACG\nACTACGACT", s.seq )
+       end
 
-               assert_equal( "ACTGACTAGCATCGACTACGACTGACACGACGACGACGACCGAACGATCGATCGCAGACGACGCAGCATGACGACGTACG\nACTACGACT", my_seq.seq )
+       def test_wrap_with_1_args!
+               s = Seq.new( "ATCG" )
 
-               my_seq.wrap!( 40 )
+               s.wrap!( 2 )
 
-               assert_equal( "ACTGACTAGCATCGACTACGACTGACACGACGACGACGAC\nCGAACGATCGATCGCAGACGACGCAGCATGACGACGTACG\nACTACGACT", my_seq.seq )
+               assert_equal( "AT\nCG", s.seq )
+       end
 
-               my_seq.wrap!( 40, "\r" )
+       def test_wrap_with_2_args!
+               s = Seq.new( "ATCG" )
 
-               assert_equal( "ACTGACTAGCATCGACTACGACTGACACGACGACGACGAC\rCGAACGATCGATCGCAGACGACGCAGCATGACGACGTACG\rACTACGACT", my_seq.seq )
+               s.wrap!( 2, "\r" )
+
+               assert_equal( "AT\rCG", s.seq )
        end
 
-       def test_generate
-               my_seq = Seq.new
+       # Testing Seq#generate
+
+       def test_generate_arg_is_a_number
+               s = Seq.new
+
+               assert_raise( RuntimeError ) { s.generate( "FOO" ) }
+       end
+
+       def test_generate_arg_is_a_positive_number
+               s = Seq.new
 
-               my_seq.seq_type = "AA"
+               assert_raise( RuntimeError ) { s.generate( 0 ) }
+               assert_raise( RuntimeError ) { s.generate( -10 ) }
+       end
 
-               assert_raise( RuntimeError ) { my_seq.generate( "FOO" ) }
-               assert_raise( RuntimeError ) { my_seq.generate( 0 ) }
-               assert_raise( RuntimeError ) { my_seq.generate( -10 ) }
+       def test_generate
+               s = Seq.new( "", "AA" )
 
-               seq = my_seq.generate( 40 )
+               seq = s.generate( 40 )
 
                assert_equal( 40, seq.length )
+       end
+
+       def test_generate_dont_change_instance_var
+               s = Seq.new( "", "AA" )
 
-               assert_equal( nil, my_seq.seq )
+               seq = s.generate( 40 )
+
+               assert_equal( "", s.seq )
        end
 
-       def test_generate!
-               my_seq = Seq.new
+       # Testing Seq#generate!
 
-               my_seq.seq_type = "AA"
+       def test_generate!
+               s = Seq.new( "", "AA" )
 
-               gen_seq = my_seq.generate!( 40 )
+               gen_seq = s.generate!( 40 )
 
                assert_equal( 40, gen_seq.length )
-               assert_equal( 40, my_seq.seq.length )
-
-               assert_equal( gen_seq, my_seq.seq )
+               assert_equal( 40, s.seq.length )
+               assert_equal( gen_seq, s.seq )
        end
 
-       def test_Seq_AA_new
-               my_seq1 = Seq::AA.new
-               assert_equal( nil, my_seq1.seq )
-               assert_equal( "AA", my_seq1.seq_type )
+       # Testing Seq::AA#initialize
+
+       def test_Seq#AA_initialize_with_0_args
+               s = Seq::AA.new
+               assert_equal( "", s.seq )
+               assert_equal( "AA", s.seq_type )
+       end
 
-               my_seq2 = Seq::AA.new( "SEQ" )
-               assert_equal( "SEQ", my_seq2.seq )
-               assert_equal( "AA",  my_seq2.seq_type )
+       def test_Seq#AA_initialize_with_1_args
+               s = Seq::AA.new( "SEQ" )
+               assert_equal( "SEQ", s.seq )
+               assert_equal( "AA",  s.seq_type )
        end
 end