tap 0.7.9

data/lib/tap/test/subset_methods.rb

@@ -0,0 +1,260 @@
+require 'test/unit'
+require 'benchmark'
+require 'pp'
+require 'tap/test/env_vars'
+
+module Test # :nodoc:
+  module Unit # :nodoc:
+    class TestCase
+      class << self
+
+        # Causes a whole test suite to require one of the listed platforms 
+        # in order to run.  See match_platform? for details.
+        #
+        # Simply declare like:
+        #
+        #   class Test::Unit::TestCase
+        #     require_platform 'mswin'
+        #   end
+        def require_platform(*platforms, &block)
+          @platforms = platforms
+          yield if block_given? && match_platform?(*@platforms)
+        end
+
+        # Returns true if RUBY_PLATFORM matches one of the specfied
+        # platforms.  Use the prefix 'non_' to specify any plaform but the 
+        # specified platform (ex: 'non_mswin')
+        #
+        # Some common platforms:
+        # - mswin:: Windows
+        # - darwin:: Mac
+        def match_platform?(*platforms)
+          platforms.each do |platform|
+            platform.to_s =~ /^(non_)?(.*)/
+
+            non = true if $1
+            match_platform = !RUBY_PLATFORM.index($2).nil?
+            return false unless (non && !match_platform) || (!non && match_platform)
+          end
+
+          true
+        end
+
+        alias :original_suite :suite
+      end      
+    end
+  end
+end
+
+module Tap
+  module Test
+    module SubsetMethods
+      include Tap::Test::EnvVars
+      
+      def self.suite
+        if match_platform?(*@platforms)
+          original_suite
+        else
+          # if platforms are specfied for the tests and the platform does NOT
+          # match, remake the suite to skip all tests.
+          method_names = public_instance_methods(true)
+          suite = Test::Unit::TestSuite.new(name)
+          method_names.each do |method_name| 
+            catch(:invalid_test) do
+              suite << new('on_test_skipped') if method_name =~ /^test/
+            end
+          end
+          suite
+        end
+      end
+
+      # Platform-specific test.  Useful for specifying test that should only be run on,
+      # for instance, windows.  See match_platform? for details.
+      def platform_test(*platforms, &block)
+        if self.class.match_platform?(*platforms)
+          yield
+        else
+          print ' '
+        end
+      end
+  
+      # Subset test declaration for extended tests -- type: EXTENDED
+      # Prints 'x' unless run.
+        def extended_test(&block) 
+        subset_test("EXTENDED", "x", &block)
+      end
+  
+      # Subset test declaration for benchmark tests -- type: BENCHMARK
+      # Prints 'b' unless run.
+      def benchmark_test(length=10, &block) 
+        subset_test("BENCHMARK") do
+          puts
+          puts calling_method
+          bm(length) do |x|
+            yield(x)
+          end
+        end
+      end
+
+      # Case tests take a hash of testcases and expected values.  Each pair in the hash will 
+      # be passed to the block if type CASE_TEST is specified.  Individual cases tests can be 
+      # specified by providing a regexp in CASE; the testcase will run if the pretty-print of
+      # the testcase matches the provided regexp.  Example:
+      #
+      #   case_test(
+      #     [1,2,3] => 'an array testcase',
+      #     '[1, 2, 3]' => 'the pretty print of the array',
+      #     'another testcase' => 'some third testcase'
+      #   ).do |testcase, expected|
+      #      ...your test code...
+      #   end
+      #
+      #   ENV['CASE_TEST']=true  => all tests run
+      #   ENV['CASE']='1, 2, 3' => first two tests run
+      #   ENV['CASE']='another' => only last test runs
+      def case_test(hash, &block)
+        if match_regexp?("CASE_TEST", calling_method)
+          hash.each_pair do |testcase, expected|
+            yield(testcase, expected) if match_regexp?("CASE", testcase)
+          end
+        end
+      end
+  
+      # Acase tests take an array of testcases.  Each testcase in the array will 
+      # be passed to the block if type CASE_TEST is specified.  Individual cases tests can be 
+      # specified by providing a regexp in CASE; the testcase will run if the pretty-print of
+      # the testcase matches the provided regexp.  Example:
+      #
+      #   case_test(
+      #     [1,2,3] ,
+      #     '[1, 2, 3]',
+      #     'another testcase'
+      #   ).do |testcase|
+      #      ...your test code...
+      #   end
+      #
+      #   ENV['CASE_TEST']=true  => all tests run
+      #   ENV['CASE']='1, 2, 3' => first two tests run
+      #   ENV['CASE']='another' => only last test runs
+      def acase_test(*array)
+        if match_regexp?("CASE_TEST", calling_method)
+          array.each do |testcase|
+            yield(testcase) if match_regexp?("CASE", testcase)
+          end
+        end  
+      end
+
+  
+      # Subset test declaration for prompt tests -- type: PROMPT
+      # Prints 'p' unless run.
+      #
+      # Useful for tests that require user input.  If run, then this test will
+      # prompt the user for an input for each item in the array.  The results
+      # are collected in a hash and passed to the block.
+      #
+      # Example:
+      # 
+      #   def test_something_important
+      #     prompt_test(:a, :b, :c).do |config|
+      #        ...your test code...
+      #     end
+      #   end
+      #
+      #   (if run, prompts print to $stdout the following:)
+      #   test_something_important: Enter values or 'skip'
+      #   a: # => enter 'avalue'
+      #   b: # => enter 'bvalue'
+      #   c: # => enter 'cvalue'
+      #
+      #   # config => {:a => 'avalue', :b => 'bvalue', :c => 'cvalue'}
+      def prompt_test(*array, &block)
+        subset_test("PROMPT", "p") do
+          puts "\n#{calling_method} -- Enter values or 'skip'."
+    
+          config = {}
+          array.each do |key|
+            print "#{key}: "
+            value = gets.strip
+            flunk "skipped test" if value =~ /skip/i
+        
+            config[key] = value
+          end
+        
+          yield(config)
+        end
+      end
+  
+      protected
+  
+      # Formats the input by using singleline_pp
+      def spp(input, str='')
+        PP.singleline_pp(input, str)
+      end
+  
+      # Required for platform tests
+      def on_test_skipped
+        print ' '
+      end
+  
+      # Returns true if the env_var(var) is set and matches /^true%/i
+      def env_true?(var)
+        env(var) && env(var) =~ /^true$/i
+      end
+  
+      # Returns true if the subset type or 'ALL' is specified in ENV
+      def run_subset?(type)
+        env_true?(type) || env_true?("ALL") ? true : false
+      end
+
+      # Returns true if the pretty-print string for obj matches the regexp specified in env_var(type).
+            # Returns the default value if 'ALL' is specified in ENV or type is not specified in ENV.  
+      def match_regexp?(type, obj, default=true)
+        return true if env_true?("ALL")
+        return default unless env(type)
+    
+        spp(obj) =~ Regexp.new(env(type)) ? true : false
+      end
+  
+      # Calling method iterates over the call stack, and returns the first calling
+      # method name that matches the input pattern (by default /^test/)
+      def calling_method(pattern=/^test/)
+        0.upto(caller.length) do |i|
+          caller[i] =~ /:in `(.*)'$/
+          method_name = $1
+          return method_name if method_name =~ pattern
+        end
+      
+        ''
+      end
+  
+      # Basic method for a subset test.  The provided block will run if:
+      #   - The subset type or 'ALL' is specified in ENV
+      #   - The calling method matches the regexp provided in the "TYPE_TEST" ENV variable
+      #  
+      # Otherwise the block will be skipped and +skip+ will be printed.  By default skip
+      # is the first letter of +type+.
+      def subset_test(type, skip=type[0..0].downcase, &block)
+        type = type.upcase
+        type_test = "#{type}_TEST"
+        if run_subset?(type) || env(type_test)
+          if match_regexp?(type_test,  calling_method)
+            yield
+          else
+            print skip
+          end
+        else
+          print skip
+        end
+      end
+  
+      # Runs only if the first argument causes an 'if' statement to return true.
+      def switch_test(run_test, skip="!", &block)
+        if run_test
+          yield
+        else
+          print skip
+        end
+      end
+    end
+  end
+end

data/lib/tap/version.rb

@@ -0,0 +1,3 @@
+module Tap
+  VERSION="0.7.9" 
+end

data/lib/tap/workflow.rb

@@ -0,0 +1,73 @@
+module Tap
+  
+  # App can build workflows directly, using methods like sequence, merge, and
+  # multithread, but these workflows are hard to abstract and resuse.  Workflow
+  # is a specialized type of Task allows the encapsulation and reuse of workflow 
+  # logic.  
+  #
+  # During initialization, Workflows execute the workflow method to define the
+  # workflow logic.  The workflow method defines an entry_point task, which is
+  # sequenced to execute after the Workflow instance completes.  Workflows by
+  # default just pass their inputs along, essentially acting as a gateway for
+  # executing entry_point:
+  #
+  #   inputs to workflow
+  #   workflow executes (does nothing)
+  #   on_complete entry_point recieves inputs
+  #   entry_point executes, beginning workflow logic
+  # 
+  # Since entry_point and all other tasks in the workflow logic are defined
+  # in the workflow method, they can be made instance-specific.  Thus you can 
+  # instantiate a Workflow many times and use them at many points in a larger
+  # workflow, or in a multithreaded way.
+  #
+  # Notes: 
+  # - The default Workflow uses the task blocks to define workflow logic, NOT 
+  # process logic as in Task.  
+  class Workflow < Task
+    attr_accessor :entry_point, :exit_point
+
+    def initialize(*args)
+      super
+      
+      self.entry_point = {}
+      self.exit_point = {}
+      self.workflow
+      
+      case entry_point
+      when Hash, Array
+        raise WorkflowError.new("No entry points defined") if entry_point.empty?
+        targets = entry_point.kind_of?(Hash) ? entry_point.values : entry_point
+        fork(self, *targets)
+      when Task
+        sequence(self, entry_point)
+      else
+        raise WorkflowError.new("No entry point defined")
+      end
+    end
+
+    def sequence(*tasks)
+      app.sequence(*tasks)
+    end
+    
+    def fork(source, *targets)
+      app.fork(source, *targets)
+    end
+    
+    def merge(target, *sources)
+      app.merge(target, *sources)
+    end
+    
+    def workflow
+      raise WorkflowError.new("No workflow definition provided.") unless task_block
+      task_block.call(self) 
+    end
+    
+    def process(input)
+      input
+    end
+    
+    class WorkflowError < Exception # :nodoc:
+    end
+  end
+end

data/test/app/config/addition_template.yml

@@ -0,0 +1,6 @@
+factor0: 0
+
+variations!:
+   - factor1: 10
+   - factor0: 1
+     factor1: 20

data/test/app/config/batch.yml

@@ -0,0 +1,2 @@
+- key: one
+- key: two

data/test/app/config/erb.yml

@@ -0,0 +1 @@
+sum: <%= 1 + 2 %>

data/test/app/config/template.yml

@@ -0,0 +1,6 @@
+default_field: default value
+
+variations!:
+  - field: item one
+  - field: item two
+    default_field: non-default value

data/test/app/config/version-0.1.yml

@@ -0,0 +1 @@
+version: 0.1

data/test/app/config/version.yml

@@ -0,0 +1 @@
+version: empty

data/test/app/lib/app_test_task.rb

@@ -0,0 +1,2 @@
+class AppTestTask < Tap::Task
+end

data/test/app_class_test.rb

@@ -0,0 +1,33 @@
+require  File.join(File.dirname(__FILE__), 'tap_test_helper')
+require 'tap/app'
+
+class AppClassTest < Test::Unit::TestCase
+	include Tap
+
+  #
+  # instance tests
+  #
+  
+  def test_instance_returns_current_instance_or_a_default_app
+    a = App.new
+    App.instance = a
+    assert_equal a, App.instance
+    
+    App.instance = nil
+    assert_equal App, App.instance.class
+  end
+  
+  #
+  # parse_yaml tests
+  #
+  
+  def test_parse_yaml_loads_arg_if_arg_matches_yaml_document_string
+    string = "---\nkey: value"
+    assert_equal({"key" => "value"}, App.parse_yaml(string))
+  end
+  
+  def test_parse_yaml_returns_arg_unless_matches_yaml_document_string
+    string = "key: value"
+    assert_equal("key: value", App.parse_yaml(string))
+  end
+end

data/test/app_test.rb

@@ -0,0 +1,1372 @@
+require  File.join(File.dirname(__FILE__), 'tap_test_helper')
+require 'tap/app'
+require 'stringio'
+require 'logger'
+
+class AppTest < Test::Unit::TestCase
+	include Tap
+  acts_as_tap_test
+	
+	def setup
+		super
+		app.queue.clear
+	end
+	
+	# 
+	# initialization tests
+	#
+	
+	def test_default_app
+		app = App.new
+		
+		assert_equal Dir.pwd, app.root
+		assert_equal({}, app.directories)
+		assert_equal({}, app.options.marshal_dump)
+		assert_equal({}, app.map)
+		assert_equal App::State::READY, app.state
+	end
+	
+	#
+	# task config tests
+	#
+	
+	def test_config_returns_current_configurations
+    app = App.new
+    expected = {
+      :root => Dir.pwd,
+      :directories => {},
+      :absolute_paths => {},
+      :options => {},
+      :logger => {
+        :device => STDOUT,
+        :level => 1, # corresponds to 'INFO'
+        :datetime_format => '%H:%M:%S'},
+      :load_paths => []
+    }
+    assert_equal expected, app.config
+    
+    # now try with a variety of configurations changed
+    app.options.trace = true
+    app[:lib] = 'alt/lib'
+    app[:abs, true] = '/absolute/path'
+    strio = StringIO.new('')
+    app.logger = Logger.new(strio)
+    app.load_paths << "path"
+    
+    expected = {
+      :root => Dir.pwd,
+      :directories => {:lib => 'alt/lib'},
+      :absolute_paths => {:abs => '/absolute/path'},
+      :options => {:trace => true},
+      :logger => {
+        :device => strio,
+        :level => 0, 
+        :datetime_format => nil},
+      :load_paths => ["path"]
+    }
+    
+    assert_equal 0, app.logger.level
+    assert_equal nil, app.logger.datetime_format
+    assert_equal expected, app.config
+  end
+  
+  #
+  # reconfigure test
+  #
+	
+  def test_reconfigure_may_overrride_root_directories_options_and_logging
+    app = App.new
+    
+    assert_equal Dir.pwd, app.root
+    app.reconfigure :root => './alt/root'
+    assert_equal './alt/root', app.root
+    
+    assert_equal({}, app.directories)
+    app.reconfigure :directories => {:lib => 'alt/lib'}
+    assert_equal({:lib => 'alt/lib'}, app.directories)
+    
+    assert_equal({}, app.options.marshal_dump)
+    app.reconfigure :options => {:trace => true}
+    assert_equal({:trace => true}, app.options.marshal_dump)
+    
+    assert_equal STDOUT, app.logger.logdev.dev
+    strio = StringIO.new('')
+    app.reconfigure :logger => {:device => strio, :level => Logger::WARN}
+    assert_equal strio, app.logger.logdev.dev
+    assert_equal Logger::WARN, app.logger.level
+  end
+  
+	#
+	# set logger tests
+	#
+	
+	def test_set_logger_extends_logger_with_support_logger
+		output = StringIO.new('')
+		logger = Logger.new(output)
+		assert !logger.respond_to?(:section_break)
+		
+		app.logger = logger
+		assert logger.respond_to?(:section_break)
+	end
+	
+	# 
+	# TODO -- Add logging tests
+	#
+
+
+  #
+  # task tests
+  #
+  
+  class TaskSubClass < Task
+  end
+  
+  def test_task_returns_task_if_a_task_is_provided
+    task = Task.new
+    assert_equal task, app.task(task)
+    
+    subtask = TaskSubClass.new
+    assert_equal subtask, app.task(subtask)
+  end
+  
+  def test_task_reconfigures_task_with_config
+    task = Task.new
+    config = {"key" => "value"}
+    
+    assert_equal({}, task.config)
+    assert_equal task, app.task(task, config)
+    assert_equal(config.symbolize_keys, task.config)
+  end
+  
+  def test_task_looks_up_and_instantiates_task_if_task_is_a_string
+    assert_equal TaskSubClass, app.task("AppTest::TaskSubClass").class
+  end
+  
+  def test_task_translates_strings_to_class_name_using_map_if_possible
+    app.map["mapped_name"] = "AppTest::TaskSubClass"
+    assert_equal TaskSubClass, app.task("mapped_name").class
+  end
+  
+  def test_task_translates_strings_to_class_name_using_camelize_by_default
+    assert_equal TaskSubClass, app.task("app_test/task_sub_class").class
+  end
+  
+  def test_task_name_and_version_is_respected
+    t = app.task("app_test/task_sub_class-1.1")
+    assert_equal TaskSubClass, t.class
+    assert_equal "app_test/task_sub_class-1.1", t.name
+  end
+  
+  def test_task_can_find_task_classes_along_Dependencies_load_paths
+    begin
+      Dependencies.load_paths << app['lib']
+      assert_equal AppTestTask, app.task("AppTestTask").class
+    ensure
+      Dependencies.load_paths.delete(app['lib'])
+    end
+  end
+  
+  def test_task_raises_error_if_class_cannot_be_found
+    assert_raise(RuntimeError) { app.task("NonExistant") }
+  end
+  
+  #
+	# config_templates tests
+	#
+  
+	def test_config_templates_retrieves_templates_for_the_specified_task_config_file
+	  filepath = app.filepath('config', "version.yml")
+	  assert File.exists?(filepath)
+		assert_equal [{"version" => "empty"}], app.config_templates(filepath)
+		
+		filepath = app.filepath('config', "version-0.1.yml")
+		assert File.exists?(filepath)
+		assert_equal [{"version" => 0.1}], app.config_templates(filepath)
+	end
+	
+	def test_config_templates_can_load_an_array_of_templates	
+		filepath = app.filepath('config', "batch.yml")
+		assert File.exists?(filepath)
+		assert_equal [{"key" => "one"}, {"key" => "two"}], app.config_templates(filepath)
+	end
+
+	def test_config_templates_returns_empty_template_even_if_config_file_does_not_exist
+    filepath = app.filepath('config', "non_existant.yml")
+    assert !File.exists?(filepath)
+		assert_equal [{}], app.config_templates(filepath)
+  end
+  
+  def test_config_templates_returns_empty_template_if_config_file_is_empty
+    filepath = app.filepath('config', "empty.yml")
+    assert File.exists?(filepath)
+    assert_equal "", File.read(filepath)
+		assert_equal [{}], app.config_templates(filepath)
+  end
+  
+  def test_config_templates_templates_using_erb
+	  filepath = app.filepath('config', "erb.yml")
+  	assert_equal [{"sum" => 3}], app.config_templates(filepath)
+	end
+  
+  #
+  # execute test
+  #
+  
+  def test_execute_executes_task_with_inputs
+    t = Task.new(&add_one)
+    t.enq(1,2,3)
+    
+		app.execute(t)
+		assert_inputs(t => [1,2,3])
+		assert_outputs(t => [2,3,4])
+		assert_equal [1,2,3], runlist
+		assert_audits(t.results, 
+			0 => [[nil,1], [t,2]],
+			1 => [[nil,2], [t,3]],
+			2 => [[nil,3], [t,4]])
+  end
+  
+	#
+	# run tests
+	#
+
+	def test_run_single_task
+		t = Task.new(&add_one)
+		app.run(t,1,2,3)
+		assert_inputs(t => [1,2,3])
+		assert_outputs(t => [2,3,4])
+		assert_equal [1,2,3], runlist
+		assert_audits(t.results, 
+			0 => [[nil,1], [t,2]],
+			1 => [[nil,2], [t,3]],
+			2 => [[nil,3], [t,4]])
+	end
+	
+	def test_run_single_task_from_a_thread
+	  t = Task.new(&add_one)
+	  
+	  th = Thread.new { app.run(t,1,2,3) }
+	  th.join
+	  
+		assert_inputs(t => [1,2,3])
+		assert_outputs(t => [2,3,4])
+		assert_equal [1,2,3], runlist
+		assert_audits(t.results, 
+			0 => [[nil,1], [t,2]],
+			1 => [[nil,2], [t,3]],
+			2 => [[nil,3], [t,4]])
+	end
+  
+  #
+	# multithread test
+	#
+  
+  def test_main_thread_execution_waits_for_multithread_execution
+    extended_test do
+      main_thread_ran = false
+      multithread_ran = false
+      
+      multithread_executing = false
+      main_thread_did_not_wait = false
+    
+	    t1 = Task.new do |task, input|
+        main_thread_ran = true
+        main_thread_did_not_wait = true if multithread_executing
+      end
+    
+	    t2 = Task.new do |task, input|
+        multithread_ran = true
+        multithread_executing = true
+      
+        # sleep is necessary so the other threads
+        # have an opportunity to execute
+        sleep(0.2) 
+        
+        multithread_executing = false
+      end
+      t2.multithread = true
+      
+      t2.enq nil
+      t1.enq nil
+      
+      app.run
+      
+      assert main_thread_ran
+      assert multithread_ran
+      assert !main_thread_did_not_wait
+    end
+	end
+  
+  def test_multithread_execution_waits_for_main_thread_execution
+    extended_test do
+      main_thread_ran = false
+      multithread_ran = false
+      
+      multithread_did_not_wait = false
+      main_thread_executing = false
+    
+	    t1 = Task.new do |task, input|
+        multithread_ran = true
+        multithread_did_not_wait = true if main_thread_executing
+      end
+      t1.multithread = true
+    
+	    t2 = Task.new do |task, input|
+        main_thread_ran = true
+        main_thread_executing = true
+      
+        # sleep is necessary so the other threads
+        # have an opportunity to execute
+        sleep(0.2) 
+        
+        main_thread_executing = false
+      end
+      
+      t1.enq nil
+      t2.enq nil
+      
+      app.run
+      
+      assert main_thread_ran
+      assert multithread_ran
+      assert !multithread_did_not_wait
+    end
+	end
+	
+	def test_only_max_threads_will_be_executed_at_a_time
+		extended_test do
+			max_threads = 0
+			n_threads = 0
+			
+			# the logic of this test is that IF app executes
+			# in a multithreaded manner, then max_threads will
+			# be greater than 1. Furthermore, IF the :max_threads
+			# option is respected, then max_threads shouldn't be
+			# greater than 2.
+			block = lambda do
+				n_threads += 1
+				max_threads = n_threads if n_threads > max_threads
+        
+        # sleep is necessary so the other threads
+        # have an opportunity to execute
+				sleep(0.2) 
+        
+				n_threads -= 1
+				nil
+			end
+			
+			t1 = Task.new(&block)
+			t2 = Task.new(&block)
+			t3 = Task.new(&block)
+			
+			with_options(:max_threads => 2) do
+			  t1.enq nil
+			  t2.enq nil
+			  t3.enq nil 
+				app.multithread(t1,t2,t3)
+				
+				app.run
+			
+				assert_equal 2, max_threads
+			end
+		end
+	end
+	
+	def test_a_multithreaded_task_executes_only_on_one_thread_at_a_time
+		extended_test do
+			max_threads = 0
+			n_threads = 0
+      count = 0
+	    threads = []
+      
+			# if multithread execution happened, then max_threads will be greater than 1.
+      # (here we want max_threads to be == 1 indicating t1 was only executed on one
+      # task at a time, even though it may have been executed on multiple threads)
+			t1 = Task.new do |task, input|
+				n_threads += 1
+				max_threads = n_threads if n_threads > max_threads
+        
+        threads << Thread.current
+        count += 1
+        task.enq nil if count < 3
+        
+        # sleep is necessary so the other threads
+        # have an opportunity to execute
+				sleep(0.2) 
+        
+				n_threads -= 1
+				nil
+			end
+      
+			t1.enq nil
+      t1.multithread = true
+				
+      app.run
+			
+      assert max_threads == 1
+      assert count == 3
+      assert threads[0] != threads[1]
+		end
+	end
+	
+	def test_multithreaded_tasks_execute_in_order
+	  extended_test do
+			max_threads = 0
+			n_threads = 0
+			runlist = []
+			
+			# if the :max_threads option is respected, then max_threads 
+      # shouldn't be greater than 2.  if multithread execution 
+      # happened, then max_threads will be greater than 1.
+			block = lambda do |task, input|
+			  runlist << input
+			  
+				n_threads += 1
+				max_threads = n_threads if n_threads > max_threads
+        
+        # sleep is necessary so the other threads
+        # have an opportunity to execute
+				sleep(0.2) 
+        
+				n_threads -= 1
+				nil
+			end
+			
+			t1 = Task.new(&block)
+			t2 = Task.new(&block)
+			t3 = Task.new(&block)
+			
+			with_options(:max_threads => 2) do 
+        t1.enq 1, 2
+        t2.enq 3
+        t3.enq 4
+				app.multithread(t1,t2,t3)
+				
+				app.run
+			
+				assert_equal 2, max_threads
+				# t1 passes [1,2] as inputs
+				# t1(1) executes, then pauses, leading to 
+				# t2(3) executing.  Next t1 unpauses to execute
+				# t1(2) because no more threads are available. Lastly
+				# t3(4) executes
+				assert_equal [1,3,2,4], runlist
+			end
+    end
+	end
+	
+	def current_threads
+	  threads =  []
+	  ObjectSpace.garbage_collect
+	  sleep 0.2 # sleep to give garbage collect time to run
+	  ObjectSpace.each_object(Thread) {|t| threads << t.object_id}
+	  threads
+	end
+	
+	def extended_test_with_thread_check
+	  extended_test do
+  	  prior_threads = current_threads
+  	  yield
+  	  assert_equal prior_threads, current_threads
+    end
+	end
+	
+	def test_threads_are_clear_after_clean_multithread_exit
+	  extended_test_with_thread_check do
+	    max_threads = 0
+			n_threads = 0
+			
+	    tasks = Array.new(3) do
+        Task.new do |task, inputs|
+  				n_threads += 1
+  				max_threads = n_threads if n_threads > max_threads
+  				sleep 0.2 
+  				n_threads -= 1
+        end 
+      end
+      tasks.each do |task|
+        task.multithread = true
+        task.enq nil
+      end
+      
+      app.run
+    
+      assert_equal 3, max_threads
+	  end
+	end
+	
+	def test_threads_are_clear_after_clean_main_thread_exit
+	  extended_test_with_thread_check do
+	    max_threads = 0
+			n_threads = 0
+			
+	    tasks = Array.new(3) do
+        Task.new do |task, inputs|
+  				n_threads += 1
+  				max_threads = n_threads if n_threads > max_threads
+  				sleep 0.2 
+  				n_threads -= 1
+        end 
+      end
+      non_threaded = tasks.shift
+      tasks.each do |task|
+        task.multithread = true
+        task.enq nil
+      end
+      non_threaded.enq nil
+      
+      app.run
+    
+      assert_equal 2, max_threads
+	  end
+	end
+
+  
+  #
+  # stop test
+  #
+  
+  def test_stop_prevents_non_executing_tasks_from_executing_on_main_thread
+    extended_test do
+      count = 0
+      tasks = Array.new(5) do
+        Task.new do |task, inputs|
+          count += 1
+          app.stop if count == 2
+        end 
+      end
+  		tasks.each do |task| 
+  		  task.enq nil
+  		end
+
+  		# under these conditions, 2 tasks should be
+  		# executed on 2 threads, and 2 additional tasks
+  		# dequeued into the thread queue.  on stop, the 2
+  		# executing tasks should finish normally, and NO MORE
+  		# tasks executed.  The waiting tasks will be requeued.
+  		with_options :max_threads => 2 do
+    		app.run
+    	end
+    	
+  		assert_equal 2, count
+  		assert_equal 3, app.queue.size
+		
+  		queued_tasks = []
+  		while !app.queue.empty?
+  		  task, inputs = app.queue.deq
+  		  queued_tasks << task.object_id 
+  		end
+		
+  		# check that the requeued tasks are in order
+  		assert_equal tasks[2...5].collect {|t| t.object_id}, queued_tasks
+  	end
+  end
+  
+  def test_stop_prevents_non_executing_tasks_from_executing_on_threads_and_requeues_thread_queue
+    extended_test do
+      count = 0
+      tasks = Array.new(5) do
+        Task.new do |task, inputs|
+          count += 1
+          sleep 0.2
+          app.stop if count == 2
+          sleep 0.2
+        end 
+      end
+  		tasks.each do |task| 
+  		  task.multithread = true
+  		  task.enq nil
+  		end
+
+  		# under these conditions, 2 tasks should be
+  		# executed on 2 threads, and 2 additional tasks
+  		# dequeued into the thread queue.  on stop, the 2
+  		# executing tasks should finish normally, and NO MORE
+  		# tasks executed.  The waiting tasks will be requeued.
+  		with_options :max_threads => 2 do
+    		app.run
+    	end
+    	
+  		assert_equal 2, count
+  		assert_equal 3, app.queue.size
+		
+  		queued_tasks = []
+  		while !app.queue.empty?
+  		  task, inputs = app.queue.deq
+  		  queued_tasks << task.object_id 
+  		end
+		
+  		# check that the requeued tasks are in order
+  		assert_equal tasks[2...5].collect {|t| t.object_id}, queued_tasks
+  	end
+  end
+
+  #
+  # terminate test
+  #
+  
+  def test_terminate_from_main_thread_raises_run_error
+    extended_test do
+      was_not_terminated = false
+      task = Task.new do |task, inputs|
+        app.terminate
+        was_not_terminated = true
+      end
+      
+      task.enq nil
+      with_options :debug => true do
+        begin
+          app.run
+          flunk "no error was raised"
+        rescue
+          assert $!.kind_of?(Tap::Support::RunError)
+          assert $!.original_error.kind_of?(Tap::App::TerminateError)
+          assert $!.terminate_errors.empty?
+        end
+      end
+    	
+		  assert !was_not_terminated
+  	end
+  end
+
+  def test_terminate_from_main_thread_when_error_is_handled_still_raises_error
+    extended_test do
+      terminate_error_handled = false
+      task = Task.new do |task, inputs|
+        begin
+          app.terminate
+        rescue
+          terminate_error_handled = true
+        end
+      end
+      
+      task.enq nil
+      with_options :debug => true do
+        begin
+          app.run
+          flunk "no error was raised"
+        rescue
+          assert $!.kind_of?(Tap::Support::RunError)
+          assert $!.original_error.kind_of?(Tap::App::TerminateError)
+          assert $!.terminate_errors.empty?
+        end
+      end
+    	
+		  assert terminate_error_handled
+  	end
+  end
+
+  def test_terminate_raises_error_on_each_execution_thread_and_requeues_thread_queue
+    extended_test do
+      count = 0
+      some_thread_was_not_terminated = false
+      tasks = Array.new(5) do
+        Task.new do |task, inputs|
+          count += 1
+          app.terminate if count == 2
+          sleep 2
+          some_thread_was_not_terminated = true
+        end 
+      end
+  		tasks.each do |task| 
+  		  task.multithread = true
+  		  task.enq nil
+  		end
+
+  		# under these conditions, 2 tasks should be
+  		# executed on 2 threads, and 2 additional tasks
+  		# dequeued into the thread queue.  on stop, the 2
+  		# executing tasks should be terminated, and NO MORE
+  		# tasks executed.  The waiting tasks will be requeued.
+  		with_options :max_threads => 2, :debug => true do
+        begin
+          app.run
+          flunk "no error was raised"
+        rescue
+          assert $!.kind_of?(Tap::Support::RunError)
+          assert $!.original_error.kind_of?(Tap::App::TerminateError)
+          assert $!.terminate_errors.empty?
+        end
+    	end
+    	
+  		assert_equal 2, count
+  		assert_equal 3, app.queue.size
+		  assert !some_thread_was_not_terminated
+      
+  		queued_tasks = []
+  		while !app.queue.empty?
+  		  task, inputs = app.queue.deq
+  		  queued_tasks << task.object_id 
+  		end
+		
+  		# check that the requeued tasks are in order
+  		assert_equal tasks[2...5].collect {|t| t.object_id}, queued_tasks
+  	end
+  end
+
+  def test_terminate_on_thread_when_error_is_handled_still_raises_error
+    extended_test do
+      count = 0
+      some_thread_was_not_terminated = false
+      handled_count = 0
+      
+      tasks = Array.new(5) do
+        Task.new do |task, inputs|
+          count += 1
+          begin
+            app.terminate if count == 2
+            sleep 2
+            some_thread_was_not_terminated = true
+          rescue
+            handled_count += 1
+          end
+        end 
+      end
+  		tasks.each do |task| 
+  		  task.multithread = true
+  		  task.enq nil
+  		end
+
+  		# under these conditions, 2 tasks should be
+  		# executed on 2 threads, and 2 additional tasks
+  		# dequeued into the thread queue.  on stop, the 2
+  		# executing tasks should be terminated, and NO MORE
+  		# tasks executed.  The waiting tasks will be requeued.
+  		with_options :max_threads => 2, :debug => true do
+        begin
+          app.run
+          flunk "no error was raised"
+        rescue
+          assert $!.kind_of?(Tap::Support::RunError)
+          assert $!.original_error.kind_of?(Tap::App::TerminateError)
+          assert $!.terminate_errors.empty?
+        end
+    	end
+    	
+    	assert !some_thread_was_not_terminated
+    	assert_equal 2, count
+    	assert_equal 2, handled_count
+    	assert_equal 3, app.queue.size
+    end
+  end
+
+  #
+  # info tests
+  #
+  
+  def test_info_provides_information_string
+    assert_equal 'state: 0 (READY) queue: 0 waiting: 0 (0) threads: 0', app.info
+  end
+
+  def test_info_can_be_called_during_a_run
+    extended_test do
+      count = 0
+      info_str = nil
+      
+      tasks = Array.new(5) do
+        Task.new do |task, inputs|
+          count += 1
+          info_str = app.info if count == 2
+          app.stop if count == 2
+          sleep 0.2
+        end 
+      end
+  		tasks.each do |task| 
+  		  task.enq nil
+  		  task.multithread = true
+  		end
+  		
+  		with_options :max_threads => 2 do
+        app.run
+    	end
+    	
+    	assert_equal 'state: 1 (RUN) queue: 3 waiting: 3 (0) threads: 2', info_str
+    	assert_equal 'state: 0 (READY) queue: 3 waiting: 3 (0) threads: 0', app.info
+  	end
+  end
+
+	#
+	# sequence tests
+	#
+	
+	def test_run_sequence
+		t1 = Task.new(&add_one)
+		t2 = Task.new(&add_one)
+		
+		app.sequence(t1,t2)
+		app.run(t1,1,2,3)
+		
+		assert_inputs(t1 => [1,2,3], t2 => [2,3,4])
+		assert_outputs(t1 => [2,3,4], t2 => [3,4,5])
+		assert_equal [1,2,3,2,3,4], runlist
+		assert_audits(t2.results, 
+			0 => [[nil,1], [t1,2], [t2,3]],
+			1 => [[nil,2], [t1,3], [t2,4]],
+			2 => [[nil,3], [t1,4], [t2,5]])
+	end
+
+	def test_run_sequence_from_trailing_task
+		t1 = Task.new(&add_one)
+		t2 = Task.new(&add_one)
+		
+		app.sequence(t1,t2)
+		app.run(t2,1,2,3)
+		
+		assert_inputs(t1 => [], t2 => [1,2,3])
+		assert_outputs(t1 => [], t2 => [2,3,4])
+		assert_equal [1,2,3], runlist
+		assert_audits(t2.results, 
+			0 => [[nil,1], [t2,2]],
+			1 => [[nil,2], [t2,3]],
+			2 => [[nil,3], [t2,4]])
+	end
+
+	#
+	# fork tests
+	#
+	
+	def test_run_fork
+		t1 = Task.new(&add_one)
+		t2 = Task.new(&add_one)
+		t3 = Task.new(&add_one)
+		
+		app.fork(t1, t2, t3)
+		app.run(t1,1,2,3)
+		
+		assert_inputs(t1 => [1,2,3], t2 => [2,3,4], t3 => [2,3,4])
+		assert_outputs(t1 => [2,3,4], t2 => [3,4,5], t3 => [3,4,5])
+		assert_equal [1,2,3, 2,3,4, 2,3,4], runlist
+		assert_audits(t2.results, 
+			0 => [[nil,1], [t1,2], [t2,3]],
+			1 => [[nil,2], [t1,3], [t2,4]],
+			2 => [[nil,3], [t1,4], [t2,5]])
+  	assert_audits(t3.results, 
+  		0 => [[nil,1], [t1,2], [t3,3]],
+  		1 => [[nil,2], [t1,3], [t3,4]],
+  		2 => [[nil,3], [t1,4], [t3,5]])
+	end
+	
+	#
+	# merge tests
+	#
+
+	def test_run_merge
+		t1 = Task.new(&add_one)
+		t2 = Task.new(&add_one)
+		t3 = Task.new(&add_one)
+
+    # merge by default has no conditions on execution
+    # so t3 should execute immediately after t1/t2 finishes
+    # as such the results need to be collected separately
+    t3_results = []
+    t3.on_complete do |results|
+      t3_results.concat results
+    end
+
+		app.merge(t3, t1, t2)
+		app.run(t1,1,2,3)
+		app.run(t2,2,3,4)
+
+		assert_inputs(t1 => [1,2,3], t2 => [2,3,4])
+		assert_outputs(t1 => [2,3,4], t2 => [3,4,5])
+		assert_equal [1,2,3, 2,3,4, 2,3,4, 3,4,5], runlist
+		assert_audits(t3_results, 
+		  # from t1...
+			0 => [[nil,1], [t1,2], [t3,3]],
+			1 => [[nil,2], [t1,3], [t3,4]],
+			2 => [[nil,3], [t1,4], [t3,5]],
+			# from t2...
+			3 => [[nil,2], [t2,3], [t3,4]],
+			4 => [[nil,3], [t2,4], [t3,5]],
+			5 => [[nil,4], [t2,5], [t3,6]])
+	end
+	
+	#
+	# run batched task tests
+	#
+	
+	def test_run_batched_task
+		t1 = Task.new('addition_template') do |task, input|
+		  runlist << input
+		  input + task.config[:factor0] + task.config[:factor1]
+		end
+		assert_equal 2, t1.batch.length
+		
+		t1_0 = t1.batch[0]
+		t1_1 = t1.batch[1]
+		
+		assert_equal [0, 10], [t1_0.config[:factor0], t1_0.config[:factor1]]
+		assert_equal [1, 20], [t1_1.config[:factor0], t1_1.config[:factor1]]
+		
+		app.run(t1,1,2,3)
+		
+		# note same inputs fed to each template 
+		assert_equal [1,2,3, 1,2,3], runlist
+		assert_audits(t1_0.results, 
+			0 => [[nil,1], [t1_0,11]],
+			1 => [[nil,2], [t1_0,12]],
+			2 => [[nil,3], [t1_0,13]])
+		assert_audits(t1_1.results, 
+			0 => [[nil,1], [t1_1,22]],
+			1 => [[nil,2], [t1_1,23]],
+			2 => [[nil,3], [t1_1,24]])
+	end
+
+	def test_run_batched_task_with_existing_audit_trails
+		t1 = Task.new('addition_template') do |task, input|
+		  runlist << input
+		  input + task.config[:factor0] + task.config[:factor1]
+		end
+		assert_equal 2, t1.batch.length
+		
+		t1_0 = t1.batch[0]
+		t1_1 = t1.batch[1]
+		
+		assert_equal [0, 10], [t1_0.config[:factor0], t1_0.config[:factor1]]
+		assert_equal [1, 20], [t1_1.config[:factor0], t1_1.config[:factor1]]
+		
+		a = Support::Audit.new(1)
+		b = Support::Audit.new(2)
+		c = Support::Audit.new(3)
+		app.run(t1,a,b,c)
+		
+		# note same inputs fed to each template 
+		assert_equal [1,2,3, 1,2,3], runlist
+		assert_audits(t1_0.results, 
+			0 => [[nil,1], [t1_0,11]],
+			1 => [[nil,2], [t1_0,12]],
+			2 => [[nil,3], [t1_0,13]])
+		assert_audits(t1_1.results, 
+			0 => [[nil,1], [t1_1,22]],
+			1 => [[nil,2], [t1_1,23]],
+			2 => [[nil,3], [t1_1,24]])
+	end
+	
+	def test_multithread_batched_tasks_execute_cosynchronously
+    extended_test do
+      max_threads = 0
+			n_threads = 0
+			
+			block = lambda do
+				n_threads += 1
+				max_threads = n_threads if n_threads > max_threads
+        
+        # sleep is necessary so the other threads
+        # have an opportunity to execute
+				sleep(0.2) 
+        
+				n_threads -= 1
+				nil
+			end
+			
+			t1 = Task.new('addition_template', &block)
+			
+			assert_equal 2, t1.batch.length
+			t1.batch.each do |task|
+			  task.multithread = true
+			  task.enq nil
+			end
+		  
+		  app.run
+			assert_equal 2, max_threads
+    end
+	end
+
+	def test_fork_in_batched_task
+		t1, t2, t3 = Array.new(3) do
+		  Task.new('addition_template') do |task, input|
+  		  runlist << input
+  		  input + task.config[:factor0] + task.config[:factor1]
+  		end
+  	end
+  	
+  	app.fork(t1, t2, t3)
+		app.run(t1, 1,2)
+		
+		assert_equal [
+		  1,2,1,2,                  # once for each t1 template
+		  11,12,22,23, 11,12,22,23, # each result into each t2 template
+		  11,12,22,23, 11,12,22,23  # each result into each t3 template
+		   ], runlist
+		
+		# Note how all the inputs were registered to the tasks
+		# before execution... so all 4 inputs execute as a batch
+		# and the inputs execute for both templates
+		t1_0 = t1.batch[0] 
+		t1_1 = t1.batch[1] 
+		
+    t3_0 = t3.batch[0]
+ 		assert_audits(t3_0.results, 
+		0 => [[nil,1], [t1_0,11], [t3_0, 21]],
+		1 => [[nil,2], [t1_0,12], [t3_0, 22]],
+		2 => [[nil,1], [t1_1,22], [t3_0, 32]],
+		3 => [[nil,2], [t1_1,23], [t3_0, 33]])
+ 			
+ 		t3_1 = t3.batch[1]
+ 		assert_audits(t3_1.results, 
+		0 => [[nil,1], [t1_0,11], [t3_1, 32]],
+		1 => [[nil,2], [t1_0,12], [t3_1, 33]],
+		2 => [[nil,1], [t1_1,22], [t3_1, 43]],
+		3 => [[nil,2], [t1_1,23], [t3_1, 44]])
+	end
+	
+	def test_merge_batched_task
+		t1, t2, t3 = Array.new(3) do
+		  Task.new('addition_template') do |task, input|
+  		  runlist << input
+  		  input + task.config[:factor0] + task.config[:factor1]
+  		end
+  	end
+  	
+  	app.merge(t3, t1, t2)
+  	t1.enq(1,2)
+  	t2.enq(3,4)
+		app.run
+		
+		assert_equal [
+		  1,2,1,2,                  # 1,2 inputs to each t1
+		  3,4,3,4,                  # 3,4 inputs to each t2
+		  11,12,22,23, 13,14,24,25, # t1 then t2 outputs to first t3
+		  11,12,22,23, 13,14,24,25  # t1 then t2 outputs to second t3
+		  ], runlist
+		  
+	  t1_0 = t1.batch[0] 
+		t1_1 = t1.batch[1] 
+	  t2_0 = t2.batch[0] 
+		t2_1 = t2.batch[1]
+    t3_0 = t3.batch[0]
+		assert_audits(t3_0.results, 
+		  # t1 0
+			0 => [[nil,1], [t1_0,11], [t3_0,21]],
+			1 => [[nil,2], [t1_0,12], [t3_0,22]],
+			# t1 1
+			2 => [[nil,1], [t1_1,22], [t3_0,32]],
+			3 => [[nil,2], [t1_1,23], [t3_0,33]],
+		  # t2 0
+			4 => [[nil,3], [t2_0,13], [t3_0,23]],
+			5 => [[nil,4], [t2_0,14], [t3_0,24]],
+			# t2 1
+			6 => [[nil,3], [t2_1,24], [t3_0,34]],
+			7 => [[nil,4], [t2_1,25], [t3_0,35]])
+	end
+  
+	#
+	# on_complete tests
+	#
+	
+	def test_on_complete
+		t1 = Task.new(&add_one)
+		t2 = Task.new(&add_one)
+		t3 = Task.new(&add_one)
+		
+		app.on_complete(t1) do |results|
+			t2.enq results.first
+			t3.enq results.last
+		end
+		app.run(t1,1,2,3)
+		
+		assert_inputs(t1 => [1,2,3], t2 => [2], t3 => [4])
+		assert_outputs(t1 => [2,3,4], t2 => [3], t3 => [5])
+		assert_equal [1,2,3,2,4], runlist
+		assert_audits(t1.results, 
+			0 => [[nil,1], [t1,2], [t2,3]],
+			1 => [[nil,2], [t1,3]],
+			2 => [[nil,3], [t1,4], [t3,5]])
+	end
+		
+	def test_feedback_loop
+		t1 = Task.new(&add_one)
+		t2 = Task.new(&add_one)
+		t3 = Task.new(&add_one)
+
+    # distribute the results of t1 based on value
+    app.on_complete(t1) do |audits|
+			audits.each do |audit|
+				if audit < 4
+					t2.enq audit
+				else
+					t3.enq audit	
+				end
+			end
+		end
+
+    # set the results of t2 to reinvoke the workflow
+		app.sequence(t2, t1)
+		
+		# collect the results as they come to t3
+		# (t3.results does not suffice because t3.results will be
+		# reset on each invokation)
+		t3_results = []
+		app.on_complete(t3) {|audits| t3_results.concat(audits) }
+		
+		app.run(t1,1,2,3)
+		
+		assert_audits(t3_results, 
+			0 => [[nil,3], [t1,4], [t3,5]],
+			1 => [[nil,1], [t1,2], [t2,3], [t1,4], [t3,5]],
+			2 => [[nil,2], [t1,3], [t2,4], [t1,5], [t3,6]])
+	end
+		
+	#
+	# synchronization tests
+	#
+
+	def BREAK_DOES_NOT_ACTUALLY_TEST_THIStest_run_is_synchronized
+		extended_test do
+			count = 0
+			counter = Task.new do 
+				count += 1
+			end
+			
+			t1 = Thread.new { 10000.times { app.run(counter, nil) } }
+			t2 = Thread.new { 10000.times { app.run(counter, nil) } }
+			t1.join
+			t2.join
+			
+			assert_equal 20000, count
+		end
+	end
+
+	def test_task_may_be_queued_from_task_while_task_is_running
+	  count = 0
+		counter = Task.new do 
+			count += 1
+			counter.enq nil if count < 3
+		end
+	  
+	  app.run(counter, nil)
+	  assert_equal 3, count
+	end
+	
+	def test_task_can_queue_from_within_threaded_and_unthreaded_tasks
+	  threaded_count = 0
+		threaded = Task.new do 
+		  runlist << "t"
+			threaded_count += 1
+			threaded.enq nil if threaded_count < 3
+		end
+		
+		not_threaded_count = 0
+		not_threaded = Task.new do
+		  runlist << "n"
+			not_threaded_count += 1
+			not_threaded.enq nil if not_threaded_count < 3
+		end
+	  
+	  app.multithread(threaded)  
+	  threaded.enq nil
+	  not_threaded.enq nil
+
+	  app.run
+	  
+	  assert_equal [
+	    "t", "n", 
+	    "t", "n", 
+	    "t", "n"], runlist
+	  assert_equal 3, threaded_count
+	  assert_equal 3, not_threaded_count
+	end
+	
+  def test_execute_is_allowed_within_non_threaded_task
+    # execute within a threaded task deadlocks
+    t2 = Task.new(&add_one)
+    t1 = Task.new do |task, input|
+      runlist << input
+      app.queue.enq(t2, input)
+      app.execute(t2)
+
+      input += 1
+    end
+
+		app.run(t1, 1,2,3)
+
+		# remember t2, will only show the LAST input 
+		# to have been processed
+		assert_inputs(t1 => [1,2,3], t2 => [3])
+		assert_outputs(t1 => [2,3,4], t2 => [4])
+		assert_equal [1,1,2,2,3,3], runlist
+		assert_audits(t1.results, 
+			0 => [[nil,1], [t1,2]],
+			1 => [[nil,2], [t1,3]],
+			2 => [[nil,3], [t1,4]])
+		assert_audits(t2.results, 
+			0 => [[nil,3], [t2,4]])
+  end
+
+  def test_run_is_allowed_within_non_threaded_task
+    # run within a threaded task deadlocks
+    t2 = Task.new(&add_one)
+    t1 = Task.new do |task, input|
+      runlist << input
+      app.run(t2, input)
+
+      input += 1
+    end
+
+		app.run(t1, 1,2,3)
+
+		# remember t2, will only show the LAST input 
+		# to have been processed
+		assert_inputs(t1 => [1,2,3], t2 => [3])
+		assert_outputs(t1 => [2,3,4], t2 => [4])
+		assert_equal [1,1,2,2,3,3], runlist
+		assert_audits(t1.results, 
+			0 => [[nil,1], [t1,2]],
+			1 => [[nil,2], [t1,3]],
+			2 => [[nil,3], [t1,4]])
+		assert_audits(t2.results, 
+			0 => [[nil,3], [t2,4]])
+  end
+	
+  #
+  # error tests
+  #
+  
+  def set_stringio_logger
+    output = StringIO.new('')
+    app.logger = Logger.new(output)
+    output.string
+  end
+  
+  def test_unhandled_exception_on_main_thread_is_logged_by_default
+    t = Task.new {|t,i| raise "error"}
+     
+    string = set_stringio_logger
+    app.run(t, nil)
+    
+    assert string =~ /RuntimeError error/
+  end
+  
+  def test_unhandled_exception_raises_run_error_on_main_thread_when_debug
+    t = Task.new {|t,i| raise "error"}
+     
+    with_options :debug => true do
+      begin
+        app.run(t, nil)
+        flunk "no error was raised"
+      rescue
+        assert $!.kind_of?(Tap::Support::RunError)
+        assert $!.original_error.kind_of?(RuntimeError)
+        assert_equal "error", $!.original_error.message
+        assert $!.terminate_errors.empty?
+      end
+  	end
+  end
+  
+  def test_unhandled_exception_on_thread_is_logged_by_default
+    t = Task.new {|t,i| raise "error"}
+    t.multithread = true
+    
+    string = set_stringio_logger
+    app.run(t, nil)
+    
+    assert string =~ /RuntimeError error/
+  end
+  
+  def test_unhandled_exception_raises_run_error_on_thread_when_debug
+    t = Task.new {|t,i| raise "error"}
+    t.multithread = true
+    
+    with_options :debug => true do
+      begin
+        app.run(t, nil)
+        flunk "no error was raised"
+      rescue
+        assert $!.kind_of?(Tap::Support::RunError)
+        assert $!.original_error.kind_of?(RuntimeError)
+        assert_equal "error", $!.original_error.message
+        assert $!.terminate_errors.empty?
+      end
+  	end
+  end
+  
+  def test_unhandled_exception_on_thread_teminates_threads
+   extended_test do
+      count = 0
+      terminated_count = 0
+      
+      tasks = Array.new(2) do
+        Task.new do |t,i|
+          # count to make sure the tasks actually executed
+          count += 1  
+          
+          terminated_count += 1
+          sleep 2
+          
+          # this should not happen
+          terminated_count -= 1
+        end
+      end
+      terr = Task.new {|t,i| raise "error"}
+      
+      tasks << terr
+      tasks.each do |task|
+        task.multithread = true
+        task.enq nil   
+      end
+
+      with_options :debug => true do
+        begin
+          app.run
+          flunk "no error was raised"
+        rescue
+          assert $!.kind_of?(Tap::Support::RunError)
+          assert $!.original_error.kind_of?(RuntimeError)
+          assert_equal "error", $!.original_error.message
+          assert $!.terminate_errors.empty?
+        end
+    	end
+
+      assert_equal 2, count
+      assert_equal 2, terminated_count
+    end
+  end
+
+  def test_exceptions_from_handling_termination_error_are_collected
+    extended_test do
+      count = 0
+      count_in_threaded_error_handling = 0
+    
+      tasks = Array.new(2) do
+        Task.new do |t,i|
+          n = count
+          begin
+            count += 1
+            sleep 2
+          rescue
+            count_in_threaded_error_handling += 1
+            raise "term error #{n}"
+          end
+        end
+      end
+      terr = Task.new {|t,i| raise "error"}
+    
+      tasks << terr
+      tasks.each do |task|
+        task.multithread = true
+        task.enq nil   
+      end
+    
+      with_options :debug => true do
+        begin
+          app.run
+          flunk "no error was raised"
+        rescue
+          assert $!.kind_of?(Tap::Support::RunError)
+          assert $!.original_error.kind_of?(RuntimeError)
+          assert_equal "error", $!.original_error.message
+        
+          assert_equal 2, $!.terminate_errors.length
+          
+          $!.terminate_errors.each_with_index do |term_err, i|
+            assert term_err.kind_of?(RuntimeError)
+            assert_equal "term error #{i}", term_err.message
+          end
+        end
+    
+        assert_equal 2, count
+        assert_equal 2, count_in_threaded_error_handling
+      end
+    end
+  end
+end