BioDSL 1.0.0

data/test/BioDSL/commands/test_write_tree.rb

@@ -0,0 +1,122 @@
+#!/usr/bin/env ruby
+$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.github.com/maasha/BioDSL).              #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+
+require 'test/helper'
+
+# Test class for WriteTree.
+class TestWriteTree < Test::Unit::TestCase
+  def setup
+    @tmpdir = Dir.mktmpdir('BioDSL')
+
+    omit('FastTree not found') unless BioDSL::Filesys.which('FastTree')
+
+    setup_data
+
+    @file = File.join(@tmpdir, 'test.tree')
+    @p    = BioDSL::Pipeline.new
+  end
+
+  def setup_data
+    @input, @output   = BioDSL::Stream.pipe
+    @input2, @output2 = BioDSL::Stream.pipe
+
+    @output.write(SEQ: 'attgactgacg--')
+    @output.write(SEQ: 'attgactaagacg')
+    @output.write(SEQ: 'a---actgacg--')
+    @output.write(SEQ: 'a---actaagacg')
+    @output.write(SEQ: 'a---actaagacg')
+    @output.write(FOO: 'BAR')
+    @output.close
+  end
+
+  def teardown
+    FileUtils.rm_r @tmpdir if @tmpdir
+  end
+
+  test 'BioDSL::Pipeline::WriteTree with invalid options raises' do
+    assert_raise(BioDSL::OptionError) { @p.write_tree(foo: 'bar') }
+  end
+
+  test 'BioDSL::Pipeline::WriteTree to stdout outputs correctly' do
+    result = capture_stdout { @p.write_tree.run(input: @input) }
+    expected = '(1:0.00055,(3:0.0,4:0.0):0.00054,' \
+      '(0:0.00055,2:0.00054)0.996:0.34079);'
+    assert_equal(expected, result.chomp)
+  end
+
+  test 'BioDSL::Pipeline::WriteTree to file outputs correctly' do
+    @p.write_tree(output: @file).run(input: @input, output: @output2)
+    result = File.read(@file)
+    expected = '(1:0.00055,(3:0.0,4:0.0):0.00054,' \
+      '(0:0.00055,2:0.00054)0.996:0.34079);'
+    assert_equal(expected, result.chomp)
+  end
+
+  test 'BioDSL::Pipeline::WriteTree to existing file raises' do
+    `touch #{@file}`
+    assert_raise(BioDSL::OptionError) { @p.write_tree(output: @file) }
+  end
+
+  test 'BioDSL::Pipeline::WriteTree to existing file w. :force outputs OK' do
+    `touch #{@file}`
+    @p.write_tree(output: @file, force: true).run(input: @input)
+    result = File.open(@file).read
+    expected = '(1:0.00055,(3:0.0,4:0.0):0.00054,' \
+      '(0:0.00055,2:0.00054)0.996:0.34079);'
+    assert_equal(expected, result.chomp)
+  end
+
+  test 'BioDSL::Pipeline::WriteTree with flux outputs correctly' do
+    @p.write_tree(output: @file).run(input: @input, output: @output2)
+    result = File.open(@file).read
+    expected = '(1:0.00055,(3:0.0,4:0.0):0.00054,' \
+      '(0:0.00055,2:0.00054)0.996:0.34079);'
+    assert_equal(expected, result.chomp)
+
+    expected = <<-EXP.gsub(/^\s+\|/, '')
+      |{:SEQ=>"attgactgacg--"}
+      |{:SEQ=>"attgactaagacg"}
+      |{:SEQ=>"a---actgacg--"}
+      |{:SEQ=>"a---actaagacg"}
+      |{:SEQ=>"a---actaagacg"}
+      |{:FOO=>"BAR"}
+    EXP
+
+    assert_equal(expected, collect_result)
+  end
+
+  test 'BioDSL::Pipeline::WriteTree status outputs correctly' do
+    @p.write_tree(output: @file).run(input: @input, output: @output2)
+    assert_equal(6,  @p.status.first[:records_in])
+    assert_equal(6,  @p.status.first[:records_out])
+    assert_equal(5,  @p.status.first[:sequences_in])
+    assert_equal(65, @p.status.first[:residues_in])
+  end
+end

data/test/BioDSL/helpers/test_options_helper.rb

@@ -0,0 +1,272 @@
+#!/usr/bin/env ruby
+$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.github.com/maasha/BioDSL).              #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+
+require 'test/helper'
+
+# Test class for OptionHelper.
+# rubocop:disable Metrics/ClassLength,
+class TestOptionsHelper < Test::Unit::TestCase
+  include BioDSL::OptionsHelper
+
+  def setup
+    @err = BioDSL::OptionError
+  end
+
+  test '#options_allowed with disallowed option raises' do
+    options = {bar: 'foo'}
+    assert_raise(@err) { options_allowed(options, :foo) }
+  end
+
+  test '#options_allowed with allowed option dont raise' do
+    options = {foo: 'bar'}
+    assert_nothing_raised { options_allowed(options, :foo) }
+  end
+
+  test '#options_allowed with no options dont raise' do
+    options = {}
+    assert_nothing_raised { options_allowed(options, :foo) }
+  end
+
+  test '#options_allowed_values with disallowed value raises' do
+    options = {bar: 'foo'}
+    assert_raise(@err) { options_allowed_values(options, bar: [1]) }
+  end
+
+  test '#options_allowed_values with allowed value dont raise' do
+    options = {bar: 'foo'}
+    assert_nothing_raised { options_allowed_values(options, bar: ['foo']) }
+  end
+
+  test '#options_required w/o required options raises' do
+    options = {bar: 'foo'}
+    assert_raise(@err) { options_required(options, :foo) }
+  end
+
+  test '#options_required with required options dont raise' do
+    options = {bar: 'foo', one: 'two'}
+    assert_nothing_raised { options_required(options, :bar, :one) }
+  end
+
+  test '#options_required_unique with non-unique required options raises' do
+    options = {bar: 'foo', one: 'two'}
+    assert_raise(@err) { options_required_unique(options, :bar, :one) }
+  end
+
+  test '#options_required_unique with unique required options dont raise' do
+    options = {bar: 'foo', one: 'two'}
+    assert_nothing_raised { options_required_unique(options, :one) }
+  end
+
+  test '#options_unique with non-unique options raises' do
+    options = {bar: 'foo', one: 'two'}
+    assert_raise(@err) { options_unique(options, :bar, :one) }
+  end
+
+  test '#options_unique with unique options dont raise' do
+    options = {bar: 'foo', one: 'two'}
+    assert_nothing_raised { options_unique(options, :one) }
+  end
+
+  test '#options_unique with no options dont raise' do
+    options = {}
+    assert_nothing_raised { options_unique(options, :one) }
+  end
+
+  test '#options_list_unique with duplicate elements raise' do
+    options = {foo: [0, 0]}
+
+    assert_raise(@err) { options_list_unique(options, :foo) }
+  end
+
+  test '#options_list_unique with unique elements dont raise' do
+    options = {foo: [0, 1]}
+    assert_nothing_raised { options_list_unique(options, :foo) }
+  end
+
+  test '#options_tie w/o tie option raises' do
+    options = {gzip: true}
+
+    assert_raise(@err) { options_tie(options, gzip: :output) }
+  end
+
+  test '#options_tie with tie option dont raise' do
+    options = {gzip: true, output: 'foo'}
+    assert_nothing_raised { options_tie(options, gzip: :output) }
+  end
+
+  test '#options_tie with reverse tie option dont raise' do
+    options = {gzip: true, output: 'foo'}
+    assert_nothing_raised { options_tie(options, output: :gzip) }
+  end
+
+  test '#options_conflict with conflicting options raise' do
+    options = {select: true, reject: true}
+    assert_raise(@err) { options_conflict(options, select: :reject) }
+  end
+
+  test '#options_conflict with non-conflicting options dont raise' do
+    options = {select: true}
+    assert_nothing_raised { options_conflict(options, select: :reject) }
+  end
+
+  test '#options_files_exist w/o options dont raise' do
+    options = {}
+    assert_nothing_raised { options_files_exist(options, :foo) }
+  end
+
+  test '#options_files_exist with file dont raise' do
+    options = {input: __FILE__}
+    assert_nothing_raised { options_files_exist(options, :input) }
+  end
+
+  test '#options_files_exist with non-existing file raise' do
+    options = {input: 'ljg34gj324'}
+    assert_raise(@err) { options_files_exist(options, :input) }
+  end
+
+  test '#options_files_exist with one non-existing file raise' do
+    options = {input: __FILE__, input2: '32g4g24g23'}
+    assert_raise(@err) { options_files_exist(options, :input, :input2) }
+  end
+
+  test '#options_files_exist with Array of non-existing files raise' do
+    options = {input: %w(__FILE__ h23j42h34)}
+    assert_raise(@err) { options_files_exist(options, :input) }
+  end
+
+  test '#options_files_exist with Arrays of non-existing files raise' do
+    options = {input: [__FILE__], input2: ['h23j42h34']}
+    assert_raise(@err) { options_files_exist(options, :input, :input2) }
+  end
+
+  test '#options_files_exist with existing file and glob don\'t raise' do
+    glob = __FILE__.sub(/\.rb$/, '*')
+    options = {input: glob}
+    assert_nothing_raised { options_files_exist(options, :input) }
+  end
+
+  test '#options_files_exist with non-matching glob raises' do
+    options = {input: 'f234rs*d32'}
+    assert_raise(@err) { options_files_exist(options, :input) }
+  end
+
+  test '#options_files_exist_force w/o options dont raise' do
+    options = {}
+    assert_nothing_raised { options_files_exist_force(options, :input) }
+  end
+
+  test '#options_files_exist_force with force dont raise' do
+    options = {input: __FILE__, force: true}
+    assert_nothing_raised { options_files_exist_force(options, :input) }
+  end
+
+  test '#options_files_exist_force w/o force raise' do
+    options = {input: __FILE__}
+    assert_raise(@err) { options_files_exist_force(options, :input) }
+  end
+
+  test '#options_dirs_exist w/o options dont raise' do
+    options = {}
+    assert_nothing_raised { options_dirs_exist(options, :foo) }
+  end
+
+  test '#options_dirs_exist with dir dont raise' do
+    options = {input: __dir__}
+    assert_nothing_raised { options_dirs_exist(options, :input) }
+  end
+
+  test '#options_dirs_exist with non-existing dir raise' do
+    options = {input: 'ljg34gj324'}
+    assert_raise(@err) { options_dirs_exist(options, :input) }
+  end
+
+  test '#options_dirs_exist with one non-existing dir raise' do
+    options = {input: __dir__, input2: '32g4g24g23'}
+    assert_raise(@err) { options_dirs_exist(options, :input, :input2) }
+  end
+
+  test '#options_dirs_exist with Array of non-existing dirs raise' do
+    options = {input: [__dir__, 'h23j42h34']}
+    assert_raise(@err) { options_dirs_exist(options, :input) }
+  end
+
+  test '#options_dirs_exist with Arrays of non-existing dirs raise' do
+    options = {input: [__dir__], input2: ['h23j42h34']}
+    assert_raise(@err) { options_dirs_exist(options, :input, :input2) }
+  end
+
+  test '#options_assert with false statement raise' do
+    options = {min: 0}
+    assert_raise(@err) { options_assert(options, ':min > 0') }
+  end
+
+  test '#options_assert with true statement dont raise' do
+    options = {min: 0}
+    assert_nothing_raised { options_assert(options, ':min == 0') }
+  end
+
+  test '#options_glob returns correctly' do
+    glob    = __FILE__[0..-3] + '*'
+    assert_equal([__FILE__], options_glob(glob))
+  end
+
+  test '#options_glob with Array returns correctly' do
+    glob    = __FILE__[0..-3] + '*'
+    assert_equal([__FILE__, __FILE__], options_glob([glob, glob]))
+  end
+
+  test 'options_load_rc with existing option returns correctly' do
+    file = Tempfile.new('rc_file')
+
+    begin
+      File.write(file, 'test foo bar')
+      options = {foo: 123}
+      options_load_rc(options, :test, file.path)
+      assert_equal({foo: 123}, options)
+    ensure
+      file.unlink
+      file.close
+    end
+  end
+
+  test 'options_load_rc w/o existing option returns correctly' do
+    file = Tempfile.new('rc_file')
+
+    begin
+      File.write(file, 'test foo bar')
+      options = {}
+      options_load_rc(options, :test, file.path)
+      assert_equal({foo: 'bar'}, options)
+    ensure
+      file.unlink
+      file.close
+    end
+  end
+end

data/test/BioDSL/seq/test_assemble.rb

@@ -0,0 +1,98 @@
+#!/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).                        #
+#                                                                                #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+
+require 'test/helper'
+
+class TestAssemble < Test::Unit::TestCase 
+  def setup
+    @entry1 = BioDSL::Seq.new(seq: "ttttttttttATCTCGC")
+    @entry2 = BioDSL::Seq.new(seq: "naTCTCGgaaaaaaaaa")
+  end
+
+  test "#assemble with bad mismatches_max raises" do
+    assert_raise(BioDSL::AssembleError) { BioDSL::Assemble.pair(@entry1, @entry2, mismatches_max: -1) }
+  end
+
+  test "#assemble with bad overlap_max raises" do
+    assert_raise(BioDSL::AssembleError) { BioDSL::Assemble.pair(@entry1, @entry2, overlap_max: 0) }
+  end
+
+  test "#assemble with bad overlap_min raises" do
+    assert_raise(BioDSL::AssembleError) { BioDSL::Assemble.pair(@entry1, @entry2, overlap_min: 0) }
+  end
+
+  test "#assemble returns correctly" do
+    assembly = BioDSL::Assemble.pair(@entry1, @entry2)
+    assert_equal("ttttttttttatctcgCatctcggaaaaaaaaa", assembly.seq)
+  end
+
+  test "#assemble with uneven sequence length returns correctly" do
+    @entry1.seq = "tttttttttATCTCGC"
+    @entry2.seq = "naTCTCGgaaaaa"
+    assembly = BioDSL::Assemble.pair(@entry1, @entry2)
+    assert_equal("tttttttttatctcgCatctcggaaaaa", assembly.seq)
+  end
+
+  test "#assemble with subsequence returns correctly" do
+    @entry1.seq = "tttttttttATCTCGC"
+    @entry2.seq = "naTCTCG"
+    assembly = BioDSL::Assemble.pair(@entry1, @entry2)
+    assert_equal("ttttttttTATCTCGc", assembly.seq)
+  end
+
+  test "#assemble with seq_name returns correctly" do
+    @entry1.seq_name = "foo"
+    assembly = BioDSL::Assemble.pair(@entry1, @entry2)
+    assert_equal("foo:overlap=1:hamming=0", assembly.seq_name)
+    assert_equal("ttttttttttatctcgCatctcggaaaaaaaaa", assembly.seq)
+  end
+
+  test "#assemble with qual returns correctly" do
+    @entry1.qual = "00000000000000000"
+    @entry2.qual = "@@@@@@@@@@@@@@@@@"
+    assembly = BioDSL::Assemble.pair(@entry1, @entry2)
+    assert_equal("ttttttttttatctcgNatctcggaaaaaaaaa", assembly.seq)
+    assert_equal("00000000000000008@@@@@@@@@@@@@@@@", assembly.qual)
+  end
+
+  test "#assemble with mismatches_max returns correctly" do
+    assembly = BioDSL::Assemble.pair(@entry1, @entry2, mismatches_max: 10)
+    assert_equal("tttttttttTATCTCGCaaaaaaaaa", assembly.seq)
+  end
+
+  test "#assemble with overlap_max returns correctly" do
+    assembly = BioDSL::Assemble.pair(@entry1, @entry2, mismatches_max: 10, overlap_max: 7)
+    assert_equal("ttttttttttatctcgCatctcggaaaaaaaaa", assembly.seq)
+  end
+
+  test "#assemble with overlap_min returns correctly" do
+    assembly = BioDSL::Assemble.pair(@entry1, @entry2, mismatches_max: 10, overlap_min: 9)
+    assert_nil(assembly)
+  end
+end

data/test/BioDSL/seq/test_backtrack.rb

@@ -0,0 +1,176 @@
+#!/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).                        #
+#                                                                                #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+
+require 'test/helper'
+
+class BackTrackTest < Test::Unit::TestCase
+  def setup
+    #                    0         1
+    #                    01234567890123456789
+    @seq = BioDSL::Seq.new(seq: "tacgatgctagcatgcacgg")
+    @seq.extend(BioDSL::BackTrack)
+  end
+
+  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|
+      assert_nothing_raised { @seq.patscan(pattern) }
+    }
+  end
+
+  test "#patscan with bad start raises" do
+    [-1, 20].each { |start|
+      assert_raise(BioDSL::BackTrackError) { @seq.patscan("N", start: start) }
+    }
+  end
+
+  test "#patscan with OK start dont raise" do
+    [0, 19].each { |start|
+      assert_nothing_raised { @seq.patscan("N", start: start) }
+    }
+  end
+
+  test "#patscan with bad stop raises" do
+    [-1, 20].each { |stop|
+      assert_raise(BioDSL::BackTrackError) { @seq.patscan("N", stop: stop) }
+    }
+  end
+
+  test "#patscan with OK stop dont raise" do
+    [0, 19].each { |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)
+  end
+
+  test "#patscan with bad mis raises" do
+    [-1, 6].each { |mis|
+      assert_raise(BioDSL::BackTrackError) { @seq.patscan("N", max_mismatches: mis) }
+    }
+  end
+
+  test "#patscan with OK mis dont raise" do
+    [0, 5].each { |mis|
+      assert_nothing_raised { @seq.patscan("N", max_mismatches: mis) }
+    }
+  end
+
+  test "#patscan with bad ins raises" do
+    [-1, 6].each { |ins|
+      assert_raise(BioDSL::BackTrackError) { @seq.patscan("N", max_insertions: ins) }
+    }
+  end
+
+  test "#patscan with OK ins dont raise" do
+    [0, 5].each { |ins|
+      assert_nothing_raised { @seq.patscan("N", max_insertions: ins) }
+    }
+  end
+
+  test "#patscan with bad del raises" do
+    [-1, 6].each { |del|
+      assert_raise(BioDSL::BackTrackError) { @seq.patscan("N", max_deletions: del) }
+    }
+  end
+
+  test "#patscan with OK del dont raise" do
+    [0, 5].each { |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)
+  end
+
+  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)
+  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)
+  end
+
+  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)
+  end
+
+  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)
+  end
+
+  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)
+  end
+
+  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",
+                  max_mismatches: 1,
+                  max_insertions: 1,
+                  max_deletions: 1) do |hit|
+      assert_equal("tacgatgctagcatgcacgg", hit.match)
+      assert_equal(0, hit.pos)
+      assert_equal(20, hit.length)
+      break
+    end
+  end
+end