From 677558921dcb25aceb8e41529fd43358a60ba03c Mon Sep 17 00:00:00 2001 From: martinahansen Date: Tue, 30 Jun 2009 20:19:36 +0000 Subject: [PATCH] cleanded up test_seq.rb git-svn-id: http://biopieces.googlecode.com/svn/trunk@548 74ccb610-7750-0410-82ae-013aeee3265d --- code_ruby/Maasha/test/test_seq.rb | 268 +++++++++++++++++------------- 1 file changed, 154 insertions(+), 114 deletions(-) diff --git a/code_ruby/Maasha/test/test_seq.rb b/code_ruby/Maasha/test/test_seq.rb index 95b25a9..afda8ab 100755 --- 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 -- 2.39.5