BioDSL 1.0.1 → 1.0.2

data/test/BioDSL/seq/test_backtrack.rb

@@ -1,173 +1,175 @@
 #!/usr/bin/env ruby
-$:.unshift File.join(File.dirname(__FILE__), '..', '..', '..')
-
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
-#                                                                                #
-# Copyright (C) 2007-2015 Martin Asser Hansen (mail@maasha.dk).                  #
-#                                                                                #
-# This program is free software; you can redistribute it and/or                  #
-# modify it under the terms of the GNU General Public License                    #
-# as published by the Free Software Foundation; either version 2                 #
-# of the License, or (at your option) any later version.                         #
-#                                                                                #
-# This program is distributed in the hope that it will be useful,                #
-# but WITHOUT ANY WARRANTY; without even the implied warranty of                 #
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                  #
-# GNU General Public License for more details.                                   #
-#                                                                                #
-# You should have received a copy of the GNU General Public License              #
-# along with this program; if not, write to the Free Software                    #
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. #
-#                                                                                #
-# http://www.gnu.org/copyleft/gpl.html                                           #
-#                                                                                #
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
-#                                                                                #
-# This software is part of BioDSL (www.BioDSL.org).                        #
-#                                                                                #
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', '..', '..')
+
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                              #
+# Copyright (C) 2007-2015 Martin Asser Hansen (mail@maasha.dk).                #
+#                                                                              #
+# This program is free software; you can redistribute it and/or                #
+# modify it under the terms of the GNU General Public License                  #
+# as published by the Free Software Foundation; either version 2               #
+# of the License, or (at your option) any later version.                       #
+#                                                                              #
+# This program is distributed in the hope that it will be useful,              #
+# but WITHOUT ANY WARRANTY; without even the implied warranty of               #
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                #
+# GNU General Public License for more details.                                 #
+#                                                                              #
+# You should have received a copy of the GNU General Public License            #
+# along with this program; if not, write to the Free Software                  #
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,    #
+# USA.                                                                         #
+#                                                                              #
+# http://www.gnu.org/copyleft/gpl.html                                         #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                              #
+# This software is part of BioDSL (http://maasha.github.io/BioDSL).            #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
 
 require 'test/helper'
 
+# Test class for BackTrack.
 class BackTrackTest < Test::Unit::TestCase
   def setup
     #                    0         1
     #                    01234567890123456789
-    @seq = BioDSL::Seq.new(seq: "tacgatgctagcatgcacgg")
+    @seq = BioDSL::Seq.new(seq: 'tacgatgctagcatgcacgg')
     @seq.extend(BioDSL::BackTrack)
   end
 
-  test "#patscan with bad pattern raises" do
-    ["", "X", "1"].each { |pattern|
+  test '#patscan with bad pattern raises' do
+    ['', 'X', '1'].each { |pattern|
       assert_raise(BioDSL::BackTrackError) { @seq.patscan(pattern) }
     }
   end
 
-  test "#patscan with OK pattern dont raise" do
-    ["N", "atcg"].each { |pattern|
+  test '#patscan with OK pattern dont raise' do
+    ['N', 'atcg'].each { |pattern|
       assert_nothing_raised { @seq.patscan(pattern) }
     }
   end
 
-  test "#patscan with bad start raises" do
+  test '#patscan with bad start raises' do
     [-1, 20].each { |start|
-      assert_raise(BioDSL::BackTrackError) { @seq.patscan("N", start: start) }
+      assert_raise(BioDSL::BackTrackError) { @seq.patscan('N', start: start) }
     }
   end
 
-  test "#patscan with OK start dont raise" do
+  test '#patscan with OK start dont raise' do
     [0, 19].each { |start|
-      assert_nothing_raised { @seq.patscan("N", start: start) }
+      assert_nothing_raised { @seq.patscan('N', start: start) }
     }
   end
 
-  test "#patscan with bad stop raises" do
+  test '#patscan with bad stop raises' do
     [-1, 20].each { |stop|
-      assert_raise(BioDSL::BackTrackError) { @seq.patscan("N", stop: stop) }
+      assert_raise(BioDSL::BackTrackError) { @seq.patscan('N', stop: stop) }
     }
   end
 
-  test "#patscan with OK stop dont raise" do
+  test '#patscan with OK stop dont raise' do
     [0, 19].each { |stop|
-      assert_nothing_raised { @seq.patscan("N", stop: stop) }
+      assert_nothing_raised { @seq.patscan('N', stop: stop) }
     }
   end
 
-  test "#patscan with stop returns correctly" do
-    assert_nil(@seq.patmatch("G", start: 0, stop: 2))
-    assert_equal("3:1:g", @seq.patmatch("G", start: 0, stop: 3).to_s)
+  test '#patscan with stop returns correctly' do
+    assert_nil(@seq.patmatch('G', start: 0, stop: 2))
+    assert_equal('3:1:g', @seq.patmatch('G', start: 0, stop: 3).to_s)
   end
 
-  test "#patscan with bad mis raises" do
+  test '#patscan with bad mis raises' do
     [-1, 6].each { |mis|
-      assert_raise(BioDSL::BackTrackError) { @seq.patscan("N", max_mismatches: mis) }
+      assert_raise(BioDSL::BackTrackError) { @seq.patscan('N', max_mismatches: mis) }
     }
   end
 
-  test "#patscan with OK mis dont raise" do
+  test '#patscan with OK mis dont raise' do
     [0, 5].each { |mis|
-      assert_nothing_raised { @seq.patscan("N", max_mismatches: mis) }
+      assert_nothing_raised { @seq.patscan('N', max_mismatches: mis) }
     }
   end
 
-  test "#patscan with bad ins raises" do
+  test '#patscan with bad ins raises' do
     [-1, 6].each { |ins|
-      assert_raise(BioDSL::BackTrackError) { @seq.patscan("N", max_insertions: ins) }
+      assert_raise(BioDSL::BackTrackError) { @seq.patscan('N', max_insertions: ins) }
     }
   end
 
-  test "#patscan with OK ins dont raise" do
+  test '#patscan with OK ins dont raise' do
     [0, 5].each { |ins|
-      assert_nothing_raised { @seq.patscan("N", max_insertions: ins) }
+      assert_nothing_raised { @seq.patscan('N', max_insertions: ins) }
     }
   end
 
-  test "#patscan with bad del raises" do
+  test '#patscan with bad del raises' do
     [-1, 6].each { |del|
-      assert_raise(BioDSL::BackTrackError) { @seq.patscan("N", max_deletions: del) }
+      assert_raise(BioDSL::BackTrackError) { @seq.patscan('N', max_deletions: del) }
     }
   end
 
-  test "#patscan with OK del dont raise" do
+  test '#patscan with OK del dont raise' do
     [0, 5].each { |del|
-      assert_nothing_raised { @seq.patscan("N", max_deletions: del) }
+      assert_nothing_raised { @seq.patscan('N', max_deletions: del) }
     }
   end
 
-  test "#patscan perfect left is ok" do
-    assert_equal("0:7:tacgatg", @seq.patscan("TACGATG").first.to_s)
+  test '#patscan perfect left is ok' do
+    assert_equal('0:7:tacgatg', @seq.patscan('TACGATG').first.to_s)
   end
 
-  test "#patscan perfect right is ok" do
-    assert_equal("13:7:tgcacgg", @seq.patscan("TGCACGG").first.to_s)
+  test '#patscan perfect right is ok' do
+    assert_equal('13:7:tgcacgg', @seq.patscan('TGCACGG').first.to_s)
   end
 
-  test "#patscan ambiguity is ok" do
-    assert_equal("13:7:tgcacgg", @seq.patscan("TGCACNN").first.to_s)
+  test '#patscan ambiguity is ok' do
+    assert_equal('13:7:tgcacgg', @seq.patscan('TGCACNN').first.to_s)
   end
 
-  test "#patscan start is ok" do
-    assert_equal("10:1:g", @seq.patscan("N", start: 10).first.to_s)
-    assert_equal("19:1:g", @seq.patscan("N", start: 10).last.to_s)
+  test '#patscan start is ok' do
+    assert_equal('10:1:g', @seq.patscan('N', start: 10).first.to_s)
+    assert_equal('19:1:g', @seq.patscan('N', start: 10).last.to_s)
   end
 
-  test "#patscan mis left is ok" do
-    assert_equal("0:7:tacgatg", @seq.patscan("Aacgatg", max_mismatches: 1).first.to_s)
+  test '#patscan mis left is ok' do
+    assert_equal('0:7:tacgatg', @seq.patscan('Aacgatg', max_mismatches: 1).first.to_s)
   end
 
-  test "#patscan mis right is ok" do
-    assert_equal("13:7:tgcacgg", @seq.patscan("tgcacgA", max_mismatches: 1).first.to_s)
+  test '#patscan mis right is ok' do
+    assert_equal('13:7:tgcacgg', @seq.patscan('tgcacgA', max_mismatches: 1).first.to_s)
   end
 
-  test "#patscan ins left is ok" do
-    assert_equal("0:7:tacgatg", @seq.patscan("Atacgatg", max_insertions: 1).first.to_s)
+  test '#patscan ins left is ok' do
+    assert_equal('0:7:tacgatg', @seq.patscan('Atacgatg', max_insertions: 1).first.to_s)
   end
 
-  test "#patscan ins right is ok" do
-    assert_equal("13:7:tgcacgg", @seq.patscan("tgcacggA", max_insertions: 1).first.to_s)
+  test '#patscan ins right is ok' do
+    assert_equal('13:7:tgcacgg', @seq.patscan('tgcacggA', max_insertions: 1).first.to_s)
   end
 
-  test "#patscan del left is ok" do
-    assert_equal("0:7:tacgatg", @seq.patscan("acgatg", max_deletions: 1).first.to_s)
+  test '#patscan del left is ok' do
+    assert_equal('0:7:tacgatg', @seq.patscan('acgatg', max_deletions: 1).first.to_s)
   end
 
-  test "#patscan del right is ok" do
-    assert_equal("12:8:atgcacgg", @seq.patscan("tgcacgg", max_deletions: 1).first.to_s)
+  test '#patscan del right is ok' do
+    assert_equal('12:8:atgcacgg', @seq.patscan('tgcacgg', max_deletions: 1).first.to_s)
   end
 
-  test "#patscan ambiguity mis ins del all ok" do
-    assert_equal("0:20:tacgatgctagcatgcacgg", @seq.patscan("tacatgcNagGatgcCacgg",
+  test '#patscan ambiguity mis ins del all ok' do
+    assert_equal('0:20:tacgatgctagcatgcacgg', @seq.patscan('tacatgcNagGatgcCacgg',
                                                            max_mismatches: 1,
                                                            max_insertions: 1,
                                                            max_deletions: 1).first.to_s)
   end
 
-  test "#patmatch in block context returns correctly" do
-    @seq.patmatch("tacatgcNagGatgcCacgg",
+  test '#patmatch in block context returns correctly' do
+    @seq.patmatch('tacatgcNagGatgcCacgg',
                   max_mismatches: 1,
                   max_insertions: 1,
                   max_deletions: 1) do |hit|
-      assert_equal("tacgatgctagcatgcacgg", hit.match)
+      assert_equal('tacgatgctagcatgcacgg', hit.match)
       assert_equal(0, hit.pos)
       assert_equal(20, hit.length)
       break

data/test/BioDSL/seq/test_digest.rb

@@ -1,70 +1,72 @@
 #!/usr/bin/env ruby
-$:.unshift File.join(File.dirname(__FILE__), '..', '..', '..')
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', '..', '..')
 
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
-#                                                                                #
-# Copyright (C) 2007-2015 Martin Asser Hansen (mail@maasha.dk).                  #
-#                                                                                #
-# This program is free software; you can redistribute it and/or                  #
-# modify it under the terms of the GNU General Public License                    #
-# as published by the Free Software Foundation; either version 2                 #
-# of the License, or (at your option) any later version.                         #
-#                                                                                #
-# This program is distributed in the hope that it will be useful,                #
-# but WITHOUT ANY WARRANTY; without even the implied warranty of                 #
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                  #
-# GNU General Public License for more details.                                   #
-#                                                                                #
-# You should have received a copy of the GNU General Public License              #
-# along with this program; if not, write to the Free Software                    #
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. #
-#                                                                                #
-# http://www.gnu.org/copyleft/gpl.html                                           #
-#                                                                                #
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
-#                                                                                #
-# This software is part of BioDSL (www.BioDSL.org).                        #
-#                                                                                #
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                              #
+# Copyright (C) 2007-2015 Martin Asser Hansen (mail@maasha.dk).                #
+#                                                                              #
+# This program is free software; you can redistribute it and/or                #
+# modify it under the terms of the GNU General Public License                  #
+# as published by the Free Software Foundation; either version 2               #
+# of the License, or (at your option) any later version.                       #
+#                                                                              #
+# This program is distributed in the hope that it will be useful,              #
+# but WITHOUT ANY WARRANTY; without even the implied warranty of               #
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                #
+# GNU General Public License for more details.                                 #
+#                                                                              #
+# You should have received a copy of the GNU General Public License            #
+# along with this program; if not, write to the Free Software                  #
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,    #
+# USA.                                                                         #
+#                                                                              #
+# http://www.gnu.org/copyleft/gpl.html                                         #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                              #
+# This software is part of BioDSL (http://maasha.github.io/BioDSL).            #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
 
 require 'test/helper'
 
+# Test class for Digest.
 class TestDigest < Test::Unit::TestCase
   def setup
-    @entry = BioDSL::Seq.new(seq: "cgatcgatcGGATCCgagagggtgtgtagtgGAATTCcgctgc")
+    @entry = BioDSL::Seq.new(seq: 'cgatcgatcGGATCCgagagggtgtgtagtgGAATTCcgctgc')
   end
 
-  test "#each_digest with bad residue in pattern raises" do
-    assert_raise(BioDSL::DigestError) { @entry.each_digest("X", 0).to_a }
+  test '#each_digest with bad residue in pattern raises' do
+    assert_raise(BioDSL::DigestError) { @entry.each_digest('X', 0).to_a }
   end
 
-  test "#each_digest returns correctly" do
-    digests = @entry.each_digest("GGATCC", 1).to_a
+  test '#each_digest returns correctly' do
+    digests = @entry.each_digest('GGATCC', 1).to_a
     assert_equal(2, digests.size)
-    assert_equal("[0-9]", digests.first.seq_name)
-    assert_equal("cgatcgatcG", digests.first.seq)
-    assert_equal("[10-42]", digests.last.seq_name)
-    assert_equal("GATCCgagagggtgtgtagtgGAATTCcgctgc", digests.last.seq)
+    assert_equal('[0-9]', digests.first.seq_name)
+    assert_equal('cgatcgatcG', digests.first.seq)
+    assert_equal('[10-42]', digests.last.seq_name)
+    assert_equal('GATCCgagagggtgtgtagtgGAATTCcgctgc', digests.last.seq)
   end
 
-  test "#each_digest with negavive offset returns correctly" do
-    digests = @entry.each_digest("CGATCG", -1).to_a
+  test '#each_digest with negavive offset returns correctly' do
+    digests = @entry.each_digest('CGATCG', -1).to_a
     assert_equal(1, digests.size)
-    assert_equal("[0-42]", digests.first.seq_name)
+    assert_equal('[0-42]', digests.first.seq_name)
     assert_equal(@entry.seq, digests.first.seq)
   end
 
-  test "#each_digest with offset out of bounds returns correctly" do
-    digests = @entry.each_digest("AATTCcgctgc", 15).to_a
+  test '#each_digest with offset out of bounds returns correctly' do
+    digests = @entry.each_digest('AATTCcgctgc', 15).to_a
     assert_equal(1, digests.size)
-    assert_equal("[0-42]", digests.first.seq_name)
+    assert_equal('[0-42]', digests.first.seq_name)
     assert_equal(@entry.seq, digests.first.seq)
   end
 
-  test "#each_digest in block context returns correctly" do
-    @entry.each_digest("GGATCC", 1) do |digest|
-      assert_equal("[0-9]", digest.seq_name)
-      assert_equal("cgatcgatcG", digest.seq)
+  test '#each_digest in block context returns correctly' do
+    @entry.each_digest('GGATCC', 1) do |digest|
+      assert_equal('[0-9]', digest.seq_name)
+      assert_equal('cgatcgatcG', digest.seq)
       break
     end
   end

data/test/BioDSL/seq/test_dynamic.rb

@@ -1,133 +1,135 @@
 #!/usr/bin/env ruby
-$:.unshift File.join(File.dirname(__FILE__), '..', '..', '..')
-
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
-#                                                                                #
-# Copyright (C) 2007-2015 Martin Asser Hansen (mail@maasha.dk).                  #
-#                                                                                #
-# This program is free software; you can redistribute it and/or                  #
-# modify it under the terms of the GNU General Public License                    #
-# as published by the Free Software Foundation; either version 2                 #
-# of the License, or (at your option) any later version.                         #
-#                                                                                #
-# This program is distributed in the hope that it will be useful,                #
-# but WITHOUT ANY WARRANTY; without even the implied warranty of                 #
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                  #
-# GNU General Public License for more details.                                   #
-#                                                                                #
-# You should have received a copy of the GNU General Public License              #
-# along with this program; if not, write to the Free Software                    #
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. #
-#                                                                                #
-# http://www.gnu.org/copyleft/gpl.html                                           #
-#                                                                                #
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
-#                                                                                #
-# This software is part of BioDSL (www.BioDSL.org).                        #
-#                                                                                #
-# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', '..', '..')
+
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                              #
+# Copyright (C) 2007-2015 Martin Asser Hansen (mail@maasha.dk).                #
+#                                                                              #
+# This program is free software; you can redistribute it and/or                #
+# modify it under the terms of the GNU General Public License                  #
+# as published by the Free Software Foundation; either version 2               #
+# of the License, or (at your option) any later version.                       #
+#                                                                              #
+# This program is distributed in the hope that it will be useful,              #
+# but WITHOUT ANY WARRANTY; without even the implied warranty of               #
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                #
+# GNU General Public License for more details.                                 #
+#                                                                              #
+# You should have received a copy of the GNU General Public License            #
+# along with this program; if not, write to the Free Software                  #
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,    #
+# USA.                                                                         #
+#                                                                              #
+# http://www.gnu.org/copyleft/gpl.html                                         #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                              #
+# This software is part of BioDSL (http://maasha.github.io/BioDSL).            #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
 
 require 'test/helper'
 
+# Test class for Dynamic.
 class TestDynamic < Test::Unit::TestCase
   def setup
-    @p = BioDSL::Seq.new(seq_name: "test", seq: "atcg")
+    @p = BioDSL::Seq.new(seq_name: 'test', seq: 'atcg')
     @p.extend(BioDSL::Dynamic)
   end
 
-  test "#patmatch with no match returns nil" do
-    assert_nil(@p.patmatch("gggg"))
+  test '#patmatch with no match returns nil' do
+    assert_nil(@p.patmatch('gggg'))
   end
 
-  test "#patmatch with perfect match returns correctly" do
-    m = @p.patmatch("atcg")
+  test '#patmatch with perfect match returns correctly' do
+    m = @p.patmatch('atcg')
     assert_equal(0, m.beg)
-    assert_equal("atcg", m.match)
+    assert_equal('atcg', m.match)
     assert_equal(0, m.mis)
     assert_equal(0, m.ins)
     assert_equal(0, m.del)
     assert_equal(4, m.length)
   end
 
-  test "#patmatch with perfect match with ambiguity codes returns correctly" do
-    m = @p.patmatch("nnnn")
+  test '#patmatch with perfect match with ambiguity codes returns correctly' do
+    m = @p.patmatch('nnnn')
     assert_equal(0, m.beg)
-    assert_equal("atcg", m.match)
+    assert_equal('atcg', m.match)
     assert_equal(0, m.mis)
     assert_equal(0, m.ins)
     assert_equal(0, m.del)
     assert_equal(4, m.length)
   end
 
-  test "#patmatch with one mismatch and edit dist zero returns nil" do
-    assert_nil(@p.patmatch("aCcg"))
+  test '#patmatch with one mismatch and edit dist zero returns nil' do
+    assert_nil(@p.patmatch('aCcg'))
   end
 
-  test "#patmatch with one mismatch and edit dist one returns correctly" do
-    m = @p.patmatch("aCcg", 0, 1)
+  test '#patmatch with one mismatch and edit dist one returns correctly' do
+    m = @p.patmatch('aCcg', 0, 1)
     assert_equal(0, m.beg)
-    assert_equal("atcg", m.match)
+    assert_equal('atcg', m.match)
     assert_equal(1, m.mis)
     assert_equal(0, m.ins)
     assert_equal(0, m.del)
     assert_equal(4, m.length)
   end
 
-  test "#patmatch with two mismatch and edit dist one returns nil" do
-    assert_nil(@p.patmatch("aGcA", 0, 1))
+  test '#patmatch with two mismatch and edit dist one returns nil' do
+    assert_nil(@p.patmatch('aGcA', 0, 1))
   end
 
-  test "#patmatch with one insertion and edit dist zero returns nil" do
-    assert_nil(@p.patmatch("atGcg"))
+  test '#patmatch with one insertion and edit dist zero returns nil' do
+    assert_nil(@p.patmatch('atGcg'))
   end
 
-  test "#patmatch with one insertion and edit dist one returns correctly" do
-    m = @p.patmatch("atGcg", 0, 1)
+  test '#patmatch with one insertion and edit dist one returns correctly' do
+    m = @p.patmatch('atGcg', 0, 1)
     assert_equal(0, m.beg)
-    assert_equal("atcg", m.match)
+    assert_equal('atcg', m.match)
     assert_equal(0, m.mis)
     assert_equal(1, m.ins)
     assert_equal(0, m.del)
     assert_equal(4, m.length)
   end
 
-  test "#patmatch with two insertions and edit dist one returns nil" do
-    assert_nil(@p.patmatch("atGcTg", 0, 1))
+  test '#patmatch with two insertions and edit dist one returns nil' do
+    assert_nil(@p.patmatch('atGcTg', 0, 1))
   end
 
-  test "#patmatch with two insertions and edit dist two returns correctly" do
-    m = @p.patmatch("atGcTg", 0, 2)
+  test '#patmatch with two insertions and edit dist two returns correctly' do
+    m = @p.patmatch('atGcTg', 0, 2)
     assert_equal(0, m.beg)
-    assert_equal("atcg", m.match)
+    assert_equal('atcg', m.match)
     assert_equal(0, m.mis)
     assert_equal(2, m.ins)
     assert_equal(0, m.del)
     assert_equal(4, m.length)
   end
 
-  test "#patmatch with one deletion and edit distance zero returns nil" do
-    assert_nil(@p.patmatch("acg"))
+  test '#patmatch with one deletion and edit distance zero returns nil' do
+    assert_nil(@p.patmatch('acg'))
   end
 
-  test "#patmatch with one deletion and edit distance one returns correctly" do
-    m = @p.patmatch("acg", 0, 1)
+  test '#patmatch with one deletion and edit distance one returns correctly' do
+    m = @p.patmatch('acg', 0, 1)
     assert_equal(0, m.beg)
-    assert_equal("atcg", m.match)
+    assert_equal('atcg', m.match)
     assert_equal(0, m.mis)
     assert_equal(0, m.ins)
     assert_equal(1, m.del)
     assert_equal(4, m.length)
   end
 
-  test "#patscan locates three patterns ok" do
-    p = BioDSL::Seq.new(seq_name: "test", seq: "ataacgagctagctagctagctgactac")
+  test '#patscan locates three patterns ok' do
+    p = BioDSL::Seq.new(seq_name: 'test', seq: 'ataacgagctagctagctagctgactac')
     p.extend(BioDSL::Dynamic)
-    assert_equal(3, p.patscan("tag").count)
+    assert_equal(3, p.patscan('tag').count)
   end
 
-  test "#patscan with pos locates two patterns ok" do
-    p = BioDSL::Seq.new(seq_name: "test", seq: "ataacgagctagctagctagctgactac")
+  test '#patscan with pos locates two patterns ok' do
+    p = BioDSL::Seq.new(seq_name: 'test', seq: 'ataacgagctagctagctagctgactac')
     p.extend(BioDSL::Dynamic)
-    assert_equal(2, p.patscan("tag", 10).count)
+    assert_equal(2, p.patscan('tag', 10).count)
   end
 end