changed Seq.new argument to hash

[biopieces.git] / code_ruby / test / maasha / test_seq.rb

diff --git a/code_ruby/test/maasha/test_seq.rb b/code_ruby/test/maasha/test_seq.rb
index d773ae2298e77c84b206be12ff32108b600ffd87..e50271d647e1b253798f06a1aa8864d4cc0dcbe5 100755 (executable)
--- a/code_ruby/test/maasha/test_seq.rb
+++ b/code_ruby/test/maasha/test_seq.rb
@@ -35,7 +35,7 @@ class TestSeq < Test::Unit::TestCase
   end
 
   test "Seq.new with differnet length SEQ and SCORES raises" do
-    assert_raise(SeqError) { Seq.new("test", "ATCG", "dna", "hhh") }
+    assert_raise(SeqError) { Seq.new(seq_name: "test", seq: "ATCG", type: :dna, qual: "hhh") }
   end
 
   test "Seq.new_bp returns correctly" do
@@ -218,7 +218,7 @@ class TestSeq < Test::Unit::TestCase
   end
 
   test "#to_fasta wraps correctly" do
-    entry = Seq.new("test", "ATCG")
+    entry = Seq.new(seq_name: "test", seq: "ATCG")
     assert_equal(">test\nAT\nCG\n", entry.to_fasta(2))
   end
 
@@ -230,12 +230,12 @@ class TestSeq < Test::Unit::TestCase
   end
 
   test "#to_key with bad residue raises" do
-    entry = Seq.new("test", "AUCG")
+    entry = Seq.new(seq_name: "test", seq: "AUCG")
     assert_raise(SeqError) { entry.to_key }
   end
 
   test "#to_key returns correctly" do
-    entry = Seq.new("test", "ATCG")
+    entry = Seq.new(seq_name: "test", seq: "ATCG")
     assert_equal(54, entry.to_key)
   end
 
@@ -303,22 +303,22 @@ class TestSeq < Test::Unit::TestCase
   end
 
   test "#hamming_distance returns correctly" do
-    seq1 = Seq.new("test1", "ATCG")
-    seq2 = Seq.new("test2", "atgg")
+    seq1 = Seq.new(seq: "ATCG")
+    seq2 = Seq.new(seq: "atgg")
     assert_equal(1, seq1.hamming_distance(seq2))
   end
 
   test "#hamming_distance with ambiguity codes return correctly" do
-    seq1 = Seq.new("test1", "ATCG")
-    seq2 = Seq.new("test2", "atng")
+    seq1 = Seq.new(seq: "ATCG")
+    seq2 = Seq.new(seq: "atng")
 
     assert_equal(1, seq1.hamming_distance(seq2))
     assert_equal(0, seq1.hamming_distance(seq2, ambiguity: true))
   end
 
   test "#edit_distance returns correctly" do
-    seq1 = Seq.new("test1", "ATCG")
-    seq2 = Seq.new("test2", "tgncg")
+    seq1 = Seq.new(seq: "ATCG")
+    seq2 = Seq.new(seq: "tgncg")
     assert_equal(2, seq1.edit_distance(seq2))
   end
 
@@ -351,7 +351,7 @@ class TestSeq < Test::Unit::TestCase
   end
 
   test "#+ without qual returns correctly" do
-    entry = Seq.new("test1", "at") + Seq.new("test2", "cg")
+    entry = Seq.new(seq_name: "test1", seq: "at") + Seq.new(seq_name: "test2", seq: "cg")
     assert_nil(entry.seq_name)
     assert_equal("atcg", entry.seq)
     assert_nil(entry.type)
@@ -359,7 +359,7 @@ class TestSeq < Test::Unit::TestCase
   end
 
   test "#+ with qual returns correctly" do
-    entry = Seq.new("test1", "at", :dna, "II") + Seq.new("test2", "cg", :dna, "JJ")
+    entry = Seq.new(seq_name: "test1", seq: "at", type: :dna, qual: "II") + Seq.new(seq_name: "test2", seq: "cg", type: :dna, qual: "JJ")
     assert_nil(entry.seq_name)
     assert_equal("atcg", entry.seq)
     assert_equal(:dna,   entry.type)
@@ -368,32 +368,32 @@ class TestSeq < Test::Unit::TestCase
 
   test "#<< with different types raises" do
     @entry.seq = "atcg"
-    assert_raise(SeqError) { @entry << Seq.new("test", "atcg", :dna) }
+    assert_raise(SeqError) { @entry << Seq.new(seq_name: "test", seq: "atcg", type: :dna) }
   end
 
   test "#<< with missing qual in one entry raises" do
     @entry.seq  = "atcg"
     @entry.type = :dna
-    assert_raise(SeqError) { @entry << Seq.new("test", "atcg", :dna, "IIII") }
+    assert_raise(SeqError) { @entry << Seq.new(seq_name: "test", seq: "atcg", type: :dna, qual: "IIII") }
     @entry.qual = "IIII"
-    assert_raise(SeqError) { @entry << Seq.new("test", "atcg", :dna) }
+    assert_raise(SeqError) { @entry << Seq.new(seq_name: "test", seq: "atcg", type: :dna) }
   end
 
   test "#<< with nil qual in both entries dont raise" do
     @entry.seq = "atcg"
-    assert_nothing_raised { @entry << Seq.new("test", "atcg") }
+    assert_nothing_raised { @entry << Seq.new(seq_name: "test", seq: "atcg") }
   end
 
   test "#<< with qual in both entries dont raise" do
     @entry.seq  = "atcg"
     @entry.type = :dna
     @entry.qual = "IIII"
-    assert_nothing_raised { @entry << Seq.new("test", "atcg", :dna, "IIII") }
+    assert_nothing_raised { @entry << Seq.new(seq_name: "test", seq: "atcg", type: :dna, qual: "IIII") }
   end
 
   test "#<< without qual returns correctly" do
     @entry.seq  = "atcg"
-    @entry <<  Seq.new("test", "ATCG")
+    @entry <<  Seq.new(seq_name: "test", seq: "ATCG")
     assert_equal("atcgATCG", @entry.seq)
   end
 
@@ -401,13 +401,13 @@ class TestSeq < Test::Unit::TestCase
     @entry.seq  = "atcg"
     @entry.type = :dna
     @entry.qual = "HHHH"
-    @entry <<  Seq.new("test", "ATCG", :dna, "IIII")
+    @entry <<  Seq.new(seq_name: "test", seq: "ATCG", type: :dna, qual: "IIII")
     assert_equal("atcgATCG", @entry.seq)
     assert_equal("HHHHIIII", @entry.qual)
   end
 
   test "#[] with qual returns correctly" do
-    entry = Seq.new("test", "atcg", :dna, "FGHI")
+    entry = Seq.new(seq_name: "test", seq: "atcg", type: :dna, qual: "FGHI")
 
     e = entry[2]
 
@@ -420,7 +420,7 @@ class TestSeq < Test::Unit::TestCase
   end
 
   test "#[] without qual returns correctly" do
-    entry = Seq.new("test", "atcg")
+    entry = Seq.new(seq_name: "test", seq: "atcg")
 
     e = entry[2]
 
@@ -431,9 +431,9 @@ class TestSeq < Test::Unit::TestCase
   end
 
   test "[]= with qual returns correctly" do
-    entry = Seq.new("test", "atcg", :dna, "FGHI")
+    entry = Seq.new(seq_name: "test", seq: "atcg", type: :dna, qual: "FGHI")
 
-    entry[0] = Seq.new("foo", "T", :dna, "I")
+    entry[0] = Seq.new(seq_name: "foo", seq: "T", type: :dna, qual: "I")
 
     assert_equal("test", entry.seq_name)
     assert_equal("Ttcg", entry.seq)
@@ -442,9 +442,9 @@ class TestSeq < Test::Unit::TestCase
   end
 
   test "[]= without qual returns correctly" do
-    entry = Seq.new("test", "atcg")
+    entry = Seq.new(seq_name: "test", seq: "atcg")
 
-    entry[0] = Seq.new("foo", "T")
+    entry[0] = Seq.new(seq_name: "foo", seq: "T")
 
     assert_equal("test", entry.seq_name)
     assert_equal("Ttcg", entry.seq)