macroape 4.0.2 → 4.1.0

data/lib/macroape/support/inverf.rb

@@ -0,0 +1,13 @@
+module Math
+  def self.inverf(x)
+    sign = x < 0 ? -1 : 1
+    x = x.abs
+    a = 8 / (3*Math::PI) * (Math::PI-3) / (4-Math::PI)
+    part0 = ( 2/(Math::PI*a) + (Math.log(1-x*x)) / 2 )**2
+    part = -2 / (Math::PI * a) - Math.log(1-x*x)/2 + Math.sqrt(-1/a * Math.log(1-x*x) + part0)
+    sign * Math.sqrt(part)
+  end
+  def inverf(x)
+    Math.inverf(x)
+  end
+end

data/lib/macroape/support/partial_sums.rb

@@ -0,0 +1,17 @@
+class Array
+  def partial_sums(initial = 0.0)
+    sums = initial
+    map{|el| sums += el}
+  end
+end
+
+class Hash
+# {1 => 5, 4 => 3, 3 => 2}.partial_sums == {1=>5, 3=>7, 4=>10}
+  def partial_sums(initial = 0.0)
+    sums = initial
+    sort.each_with_object({}){|(k,v), hsh|
+      sums += v
+      hsh[k] = sums
+    }
+  end
+end

data/lib/macroape/version.rb

@@ -1,4 +1,4 @@
-module Macroape
-  VERSION = "4.0.2"
-  STANDALONE = false
-end
+module Macroape
+  VERSION = "4.1.0"
+  STANDALONE = false
+end

data/macroape.gemspec

@@ -1,19 +1,19 @@
-# -*- encoding: utf-8 -*-
-require File.expand_path('../lib/macroape/version', __FILE__)
-
-Gem::Specification.new do |gem|
-  gem.authors       = ["Ilya Vorontsov"]
-  gem.email         = ["prijutme4ty@gmail.com"]
-  gem.description   = %q{Macroape is an abbreviation for MAtrix CompaRisOn by Approximate P-value Estimation. It's a bioinformatic tool for evaluating similarity measure and best alignment between a pair of Position Weight Matrices(PWM), finding thresholds by P-values and vice versa and even searching a collection of motifs for the most similar ones. Used approach and application described in manual at https://docs.google.com/document/pub?id=1_jsxhMNzMzy4d2d_byAd3n6Szg5gEcqG_Sf7w9tEqWw}
-  gem.summary       = %q{PWM comparison tool using MACROAPE approach}
-  gem.homepage      = "http://autosome.ru/macroape/"
-
-  gem.files         = `git ls-files`.split($/)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.name          = "macroape"
-  gem.require_paths = ["lib"]
-  gem.version       = Macroape::VERSION
-  
-  gem.add_dependency('bioinform', '~> 0.1.10')
-end
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/macroape/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Ilya Vorontsov"]
+  gem.email         = ["prijutme4ty@gmail.com"]
+  gem.description   = %q{Macroape is an abbreviation for MAtrix CompaRisOn by Approximate P-value Estimation. It's a bioinformatic tool for evaluating similarity measure and best alignment between a pair of Position Weight Matrices(PWM), finding thresholds by P-values and vice versa and even searching a collection of motifs for the most similar ones. Used approach and application described in manual at https://docs.google.com/document/pub?id=1_jsxhMNzMzy4d2d_byAd3n6Szg5gEcqG_Sf7w9tEqWw}
+  gem.summary       = %q{PWM comparison tool using MACROAPE approach}
+  gem.homepage      = "http://autosome.ru/macroape/"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "macroape"
+  gem.require_paths = ["lib"]
+  gem.version       = Macroape::VERSION
+  
+  gem.add_dependency('bioinform', '~> 0.2.0')
+end

data/spec/count_distribution_spec.rb

@@ -1,109 +1,112 @@
-require_relative 'spec_helper'
-require_relative '../lib/macroape/counting'
-
-describe Bioinform::PWM do
-  let :matrix_first do [[1,2,3,4],[10,20,30,40],[100,200,300,400]] end
-  let :matrix_second do [[1,2,3,4],[2,3,4,5]] end
-  let :pwm_first do Bioinform::PWM.new(matrix_first) end
-  let :pwm_second do Bioinform::PWM.new(matrix_second) end
-  let :background do [0.1,0.4,0.4,0.1] end
-  let :pwm_first_on_background do pwm_first.tap{|pwm| pwm.set_parameters(background: background)} end
-  let :pwm_second_on_background do pwm_second.tap{|pwm| pwm.set_parameters(background: background)} end
-
-  context '#count_distribution_after_threshold' do
-
-    it 'should return hash of score => count for all scores >= threshold' do
-      distribution_first = pwm_first.count_distribution_after_threshold(0)
-      distribution_first.keys.should == Array.product(*matrix_first).map{|score_row| score_row.inject(&:+)}
-      distribution_first.values.uniq.should == [1]
-
-      distribution_second = pwm_second.count_distribution_after_threshold(0)
-      distribution_second.should == { 3=>1, 4=>2, 5=>3, 6=>4, 7=>3, 8=>2, 9=>1 }
-
-      distribution_second = pwm_second.count_distribution_after_threshold(5)
-      distribution_second.should == { 5=>3, 6=>4, 7=>3, 8=>2, 9=>1 }
-    end
-
-    it 'for PWMs on different background it should contain the same scores (keys of hash)' do
-      pwm_first.count_distribution_after_threshold(0).keys.sort.should == pwm_first_on_background.count_distribution_after_threshold(0).keys.sort
-      pwm_first.count_distribution_after_threshold(13).keys.sort.should == pwm_first_on_background.count_distribution_after_threshold(13).keys.sort
-    end
-
-    it 'should return hash of score => count for all scores >= threshold  when calculated on background' do
-      distribution_second = pwm_second_on_background.count_distribution_after_threshold(0)
-      distribution_second.should have_nearly_the_same_values({ 3=>0.01, 4=>0.08, 5=>0.24, 6=>0.34, 7=>0.24, 8=>0.08, 9=>0.01 }, 1e-7 )
-
-      distribution_second = pwm_second_on_background.count_distribution_after_threshold(5)
-      distribution_second.should have_nearly_the_same_values({ 5=>0.24, 6=>0.34, 7=>0.24, 8=>0.08, 9=>0.01 }, 1e-7 )
-    end
-
-    it 'should use existing precalculated hash @count_distribution if it exists' do
-      pwm = pwm_second;
-      pwm.instance_variable_set :@count_distribution, { 3=>10, 4=>20, 5=>30, 6=>40, 7=>30, 8=>20, 9=>10 }
-
-      distribution_second = pwm.count_distribution_after_threshold(0)
-      distribution_second.should == { 3=>10, 4=>20, 5=>30, 6=>40, 7=>30, 8=>20, 9=>10 }
-
-      distribution_second = pwm.count_distribution_after_threshold(5)
-      distribution_second.should == { 5=>30, 6=>40, 7=>30, 8=>20, 9=>10 }
-    end
-  end
-
-  context '#count_distribution' do
-    it 'should return hash of score => count for all available scores' do
-      pwm_second.count_distribution.should == { 3=>1, 4=>2, 5=>3, 6=>4, 7=>3, 8=>2, 9=>1 }
-    end
-
-    it 'should cache calculation in @count_distribution' do
-      pwm = pwm_second;
-      pwm.instance_variable_set :@count_distribution, { 3=>10, 4=>20, 5=>30, 6=>40, 7=>30, 8=>20, 9=>10 }
-      pwm.count_distribution.should == { 3=>10, 4=>20, 5=>30, 6=>40, 7=>30, 8=>20, 9=>10 }
-
-      pwm.instance_variable_set :@count_distribution, nil
-      pwm.count_distribution.should == { 3=>1, 4=>2, 5=>3, 6=>4, 7=>3, 8=>2, 9=>1 }
-    end
-  end
-
-  context '#pvalue_by_threshold' do
-    it 'should return probability to be >= than threshold' do
-      pwm_second.pvalue_by_threshold(7).should be_within(1e-7).of(6.0/16)
-    end
-    it 'should return probability to be >= than threshold when calculated on background' do
-      pwm_second_on_background.pvalue_by_threshold(7).should be_within(1e-7).of(0.33)
-    end
-  end
-  context '#threshold' do
-    it 'should return threshold such that according pvalue doesn\'t exceed requested value' do
-      requested_pvalue = 6.0/16
-      threshold = pwm_second.threshold(requested_pvalue)
-      pwm_second.pvalue_by_threshold(threshold).should <= requested_pvalue
-    end
-    it 'should return threshold such that according pvalue doesn\'t exceed requested value when calculated on background' do
-      requested_pvalue = 0.33
-      threshold = pwm_second_on_background.threshold(requested_pvalue)
-      pwm_second_on_background.pvalue_by_threshold(threshold).should <= requested_pvalue
-    end
-    it 'should return threshold such that according pvalue doesn\'t exceed requested value when actual pvalue isn\'t exact equal to requested' do
-      requested_pvalue = 0.335
-      threshold = pwm_second_on_background.threshold(requested_pvalue)
-      pwm_second_on_background.pvalue_by_threshold(threshold).should <= requested_pvalue
-    end
-  end
-  context '#weak_threshold' do
-  it 'should return threshold such that according pvalue exceed requested value' do
-      requested_pvalue = 6.0/16
-      threshold = pwm_second.weak_threshold(requested_pvalue)
-      pwm_second.pvalue_by_threshold(threshold).should >= requested_pvalue
-    end
-    it 'should return threshold such that according pvalue exceed requested value when calculated on background' do
-      requested_pvalue = 0.33
-      threshold = pwm_second_on_background.weak_threshold(requested_pvalue)
-      pwm_second_on_background.pvalue_by_threshold(threshold).should >= requested_pvalue
-    end
-    it 'should return threshold such that according pvalue exceed requested value when actual pvalue isn\'t exact equal to requested' do
-      requested_pvalue = 0.335
-      threshold = pwm_second_on_background.weak_threshold(requested_pvalue)
-      pwm_second_on_background.pvalue_by_threshold(threshold).should >= requested_pvalue
-    end
-  end
-end
+require_relative 'spec_helper'
+require_relative '../lib/macroape/pwm_counting'
+
+describe Bioinform::MotifModel::PWM do
+  let :matrix_first do [[1,2,3,4],[10,20,30,40],[100,200,300,400]] end
+  let :matrix_second do [[1,2,3,4],[2,3,4,5]] end
+  let :pwm_first do Bioinform::MotifModel::PWM.new(matrix_first) end
+  let :pwm_second do Bioinform::MotifModel::PWM.new(matrix_second) end
+  let :background do Bioinform::Frequencies.new([0.1,0.4,0.4,0.1]) end
+
+  let :counting_first do Macroape::PWMCounting.new(pwm_first) end
+  let :counting_second do Macroape::PWMCounting.new(pwm_second) end
+  let :counting_first_on_background do Macroape::PWMCounting.new(pwm_first, background: background) end
+  let :counting_second_on_background do Macroape::PWMCounting.new(pwm_second, background: background) end
+
+  context '#count_distribution_after_threshold' do
+
+    it 'should return hash of score => count for all scores >= threshold' do
+      distribution_first = counting_first.count_distribution_after_threshold(0)
+      expect(distribution_first.keys).to eq (matrix_first.first).product(*matrix_first[1..-1]).map{|score_row| score_row.inject(&:+)}
+      expect(distribution_first.values.uniq).to eq [1]
+
+      distribution_second = counting_second.count_distribution_after_threshold(0)
+      expect(distribution_second).to eq({ 3=>1, 4=>2, 5=>3, 6=>4, 7=>3, 8=>2, 9=>1 })
+
+      distribution_second = counting_second.count_distribution_after_threshold(5)
+      expect(distribution_second).to eq({ 5=>3, 6=>4, 7=>3, 8=>2, 9=>1 })
+    end
+
+    it 'for PWMs on different background it should contain the same scores (keys of hash)' do
+      expect(counting_first.count_distribution_after_threshold(0).keys.sort).to eq counting_first_on_background.count_distribution_after_threshold(0).keys.sort
+      expect(counting_first.count_distribution_after_threshold(13).keys.sort).to eq counting_first_on_background.count_distribution_after_threshold(13).keys.sort
+    end
+
+    it 'should return hash of score => count for all scores >= threshold  when calculated on background' do
+      distribution_second = counting_second_on_background.count_distribution_after_threshold(0)
+      expect(distribution_second).to have_nearly_the_same_values({ 3=>0.01, 4=>0.08, 5=>0.24, 6=>0.34, 7=>0.24, 8=>0.08, 9=>0.01 }, 1e-7 )
+
+      distribution_second = counting_second_on_background.count_distribution_after_threshold(5)
+      expect(distribution_second).to have_nearly_the_same_values({ 5=>0.24, 6=>0.34, 7=>0.24, 8=>0.08, 9=>0.01 }, 1e-7 )
+    end
+
+    it 'should use existing precalculated hash @count_distribution if it exists' do
+      counting = counting_second;
+      counting.instance_variable_set :@count_distribution, { 3=>10, 4=>20, 5=>30, 6=>40, 7=>30, 8=>20, 9=>10 }
+
+      distribution_second = counting.count_distribution_after_threshold(0)
+      expect(distribution_second).to eq({ 3=>10, 4=>20, 5=>30, 6=>40, 7=>30, 8=>20, 9=>10 })
+
+      distribution_second = counting.count_distribution_after_threshold(5)
+      expect(distribution_second).to eq({ 5=>30, 6=>40, 7=>30, 8=>20, 9=>10 })
+    end
+  end
+
+  context '#count_distribution' do
+    it 'should return hash of score => count for all available scores' do
+      expect(counting_second.count_distribution).to eq({ 3=>1, 4=>2, 5=>3, 6=>4, 7=>3, 8=>2, 9=>1 })
+    end
+
+    it 'should cache calculation in @count_distribution' do
+      counting = counting_second;
+      counting.instance_variable_set :@count_distribution, { 3=>10, 4=>20, 5=>30, 6=>40, 7=>30, 8=>20, 9=>10 }
+      expect(counting.count_distribution).to eq({ 3=>10, 4=>20, 5=>30, 6=>40, 7=>30, 8=>20, 9=>10 })
+
+      counting.instance_variable_set :@count_distribution, nil
+      expect(counting.count_distribution).to eq({ 3=>1, 4=>2, 5=>3, 6=>4, 7=>3, 8=>2, 9=>1 })
+    end
+  end
+
+  context '#pvalue_by_threshold' do
+    it 'should return probability to be >= than threshold' do
+      expect(counting_second.pvalue_by_threshold(7)).to be_within(1e-7).of(6.0/16)
+    end
+    it 'should return probability to be >= than threshold when calculated on background' do
+      expect(counting_second_on_background.pvalue_by_threshold(7)).to be_within(1e-7).of(0.33)
+    end
+  end
+  context '#threshold' do
+    it 'should return threshold such that according pvalue doesn\'t exceed requested value' do
+      requested_pvalue = 6.0/16
+      threshold = counting_second.threshold(requested_pvalue)
+      expect(counting_second.pvalue_by_threshold(threshold)).to be <= requested_pvalue
+    end
+    it 'should return threshold such that according pvalue doesn\'t exceed requested value when calculated on background' do
+      requested_pvalue = 0.33
+      threshold = counting_second_on_background.threshold(requested_pvalue)
+      expect(counting_second_on_background.pvalue_by_threshold(threshold)).to be <= requested_pvalue
+    end
+    it 'should return threshold such that according pvalue doesn\'t exceed requested value when actual pvalue isn\'t exact equal to requested' do
+      requested_pvalue = 0.335
+      threshold = counting_second_on_background.threshold(requested_pvalue)
+      expect(counting_second_on_background.pvalue_by_threshold(threshold)).to be <= requested_pvalue
+    end
+  end
+  context '#weak_threshold' do
+  it 'should return threshold such that according pvalue exceed requested value' do
+      requested_pvalue = 6.0/16
+      threshold = counting_second.weak_threshold(requested_pvalue)
+      expect(counting_second.pvalue_by_threshold(threshold)).to be >= requested_pvalue
+    end
+    it 'should return threshold such that according pvalue exceed requested value when calculated on background' do
+      requested_pvalue = 0.33
+      threshold = counting_second_on_background.weak_threshold(requested_pvalue)
+      expect(counting_second_on_background.pvalue_by_threshold(threshold)).to be >= requested_pvalue
+    end
+    it 'should return threshold such that according pvalue exceed requested value when actual pvalue isn\'t exact equal to requested' do
+      requested_pvalue = 0.335
+      threshold = counting_second_on_background.weak_threshold(requested_pvalue)
+      expect(counting_second_on_background.pvalue_by_threshold(threshold)).to be >= requested_pvalue
+    end
+  end
+end

data/spec/inverf_spec.rb

@@ -0,0 +1,23 @@
+require_relative 'spec_helper'
+require 'macroape/support/inverf'
+
+describe 'Math#inverf' do
+  it 'should be erf(inverf(x)) == x' do
+    rng = (-0.9..0.9).step(0.1)
+    arr = rng.to_a
+    arr2 = rng.map{|x| Math.inverf(x)}.map{|x| Math.erf(x)}
+    delta = arr.each_index.map{|i| (arr[i] - arr2[i]).abs }
+    delta.each{|el|
+      expect(el).to be <= 0.001
+    }
+  end
+  it 'should be erf(inverf(x)) == x' do
+    rng = (-5..5).step(1)
+    arr = rng.to_a
+    arr2 = rng.map{|x| Math.erf(x)}.map{|x| Math.inverf(x)}
+    delta = arr.each_index.map{|i| (arr[i] - arr2[i]).abs }
+    delta.each{|el|
+      expect(el).to be <= 0.01
+    }
+  end
+end

data/spec/partial_sums_spec.rb

@@ -0,0 +1,28 @@
+require_relative 'spec_helper'
+require 'macroape/support/partial_sums'
+
+describe 'Array#partial_sums' do
+  context 'when no initial value given' do
+    it 'should return an array of the same size with partial sums of elements 0..ind inclusive with float elements' do
+      expect([2,3,4,5].partial_sums).to eq [2, 5, 9, 14]
+      expect([2,3,4,5].partial_sums.last).to be_kind_of(Float)
+    end
+  end
+  it 'should start counting from argument when it\'s given. Type of values depends on type of initial value' do
+    expect([2,3,4,5].partial_sums(100)).to eq [102,105,109,114]
+    expect([2,3,4,5].partial_sums(100).last).to be_kind_of(Integer)
+  end
+end
+
+describe 'Hash#partial_sums' do
+  context 'when no initial value given' do
+    it 'should return a hash with float values of the same size with partial sums of elements that has keys <= than argument' do
+      expect({1 => 5, 4 => 3, 3 => 2}.partial_sums).to eq({1=>5, 3=>7, 4=>10})
+      expect({1 => 5, 4 => 3, 3 => 2}.partial_sums.values.last).to be_kind_of(Float)
+    end
+  end
+  it 'should start counting from argument when it\'s given. Type of values depends on type of initial value' do
+    expect({1 => 5, 4 => 3, 3 => 2}.partial_sums(100)).to eq({1=>105, 3=>107, 4=>110})
+    expect({1 => 5, 4 => 3, 3 => 2}.partial_sums(100).values.last).to be_kind_of(Integer)
+  end
+end

data/spec/spec_helper.rb

@@ -1,11 +1,11 @@
-$bioinform_folder = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'bioinform', 'lib'))
-$LOAD_PATH.unshift $bioinform_folder
-
-require 'rspec'
-
-# comparing hashes with float values
-RSpec::Matchers.define :have_nearly_the_same_values do |expected, vicinity|
-  match do |actual|
-    expected.all?{|key, _| actual.has_key?(key)} && actual.all?{|key, _| expected.has_key?(key)} && expected.all?{|key, value| (actual[key] - value).abs <= vicinity }
-  end
-end
+$bioinform_folder = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'bioinform', 'lib'))
+$LOAD_PATH.unshift $bioinform_folder
+
+require 'rspec'
+
+# comparing hashes with float values
+RSpec::Matchers.define :have_nearly_the_same_values do |expected, vicinity|
+  match do |actual|
+    expected.all?{|key, _| actual.has_key?(key)} && actual.all?{|key, _| expected.has_key?(key)} && expected.all?{|key, value| (actual[key] - value).abs <= vicinity }
+  end
+end

data/test/align_motifs_test.rb

@@ -1,43 +1,42 @@
-require_relative 'test_helper'
-
-class TestAlignmotifs < Test::Unit::TestCase
-  def setup
-    @start_dir = Dir.pwd
-    Dir.chdir File.join(File.dirname(__FILE__), 'data')
-  end
-  def teardown
-    Dir.chdir(@start_dir)
-  end
-
-  def test_align_motifs
-    assert_equal [%w[KLF4_f2.pwm 0 direct],
-                  %w[KLF3_f1.pwm -4 direct],
-                  %w[SP1_f1_revcomp.pwm -1 revcomp]],
-      Helpers.align_motifs_output('KLF4_f2.pwm  KLF3_f1.pwm  SP1_f1_revcomp.pwm')
-  end
-  def test_align_pcm_motifs
-    assert_equal [%w[KLF4_f2.pcm 0 direct],
-                  %w[KLF3_f1.pcm -4 direct],
-                  %w[SP1_f1_revcomp.pcm -1 revcomp]],
-      Helpers.align_motifs_output('--pcm KLF4_f2.pcm  KLF3_f1.pcm  SP1_f1_revcomp.pcm')
-  end
-  def test_names_from_stdin_leader_specified
-    assert_equal [%w[KLF4_f2.pwm 0 direct],
-                  %w[KLF3_f1.pwm -4 direct],
-                  %w[SP1_f1_revcomp.pwm -1 revcomp]],
-      Helpers.provide_stdin('KLF3_f1.pwm  SP1_f1_revcomp.pwm'){ Helpers.align_motifs_output('KLF4_f2.pwm') }
-  end
-  def test_names_from_stdin_leader_not_specified
-    assert_equal [%w[KLF4_f2.pwm 0 direct],
-                  %w[KLF3_f1.pwm -4 direct],
-                  %w[SP1_f1_revcomp.pwm -1 revcomp]],
-      Helpers.provide_stdin('KLF4_f2.pwm  KLF3_f1.pwm  SP1_f1_revcomp.pwm'){ Helpers.align_motifs_output('') }
-  end
-  def test_names_from_stdin_duplicate_leader
-    assert_equal [%w[KLF4_f2.pwm 0 direct],
-                  %w[KLF3_f1.pwm -4 direct],
-                  %w[SP1_f1_revcomp.pwm -1 revcomp]],
-      Helpers.provide_stdin('KLF3_f1.pwm KLF4_f2.pwm SP1_f1_revcomp.pwm'){ Helpers.align_motifs_output('KLF4_f2.pwm') }
-  end
-
-end
+require_relative 'test_helper'
+
+class TestAlignmotifs < Test::Unit::TestCase
+  def setup
+    @start_dir = Dir.pwd
+    Dir.chdir File.join(File.dirname(__FILE__), 'data')
+  end
+  def teardown
+    Dir.chdir(@start_dir)
+  end
+
+  def test_align_motifs
+    assert_equal [%w[KLF4_f2.pwm 0 direct],
+                  %w[KLF3_f1.pwm -4 direct],
+                  %w[SP1_f1_revcomp.pwm -1 revcomp]],
+      Helpers.align_motifs_output('KLF4_f2.pwm  KLF3_f1.pwm  SP1_f1_revcomp.pwm')
+  end
+  def test_align_pcm_motifs
+    assert_equal [%w[KLF4_f2.pcm 0 direct],
+                  %w[KLF3_f1.pcm -4 direct],
+                  %w[SP1_f1_revcomp.pcm -1 revcomp]],
+      Helpers.align_motifs_output('--pcm KLF4_f2.pcm  KLF3_f1.pcm  SP1_f1_revcomp.pcm')
+  end
+  def test_names_from_stdin_leader_specified
+    assert_equal [%w[KLF4_f2.pwm 0 direct],
+                  %w[KLF3_f1.pwm -4 direct],
+                  %w[SP1_f1_revcomp.pwm -1 revcomp]],
+      Helpers.provide_stdin('KLF3_f1.pwm  SP1_f1_revcomp.pwm'){ Helpers.align_motifs_output('KLF4_f2.pwm') }
+  end
+  def test_names_from_stdin_leader_not_specified
+    assert_equal [%w[KLF4_f2.pwm 0 direct],
+                  %w[KLF3_f1.pwm -4 direct],
+                  %w[SP1_f1_revcomp.pwm -1 revcomp]],
+      Helpers.provide_stdin('KLF4_f2.pwm  KLF3_f1.pwm  SP1_f1_revcomp.pwm'){ Helpers.align_motifs_output('') }
+  end
+  def test_names_from_stdin_duplicate_leader
+    assert_equal [%w[KLF4_f2.pwm 0 direct],
+                  %w[KLF3_f1.pwm -4 direct],
+                  %w[SP1_f1_revcomp.pwm -1 revcomp]],
+      Helpers.provide_stdin('KLF3_f1.pwm KLF4_f2.pwm SP1_f1_revcomp.pwm'){ Helpers.align_motifs_output('KLF4_f2.pwm') }
+  end
+end