tap 0.8.0 → 0.9.0

data/lib/tap/workflow.rb

@@ -1,75 +1,203 @@
 module Tap
   
-  # == UNDER CONSTRUCTION
+  # == Overview
   #
   # 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
+  # logic.  See Tap::Task for the shared documentation.
+  #
+  # === Workflow Definition
+  #
+  # During initialization, Workflow executes the workflow method (by default the
+  # block provided to Workflow.new) to define the workflow logic.  This method
+  # defines one or more entry_points and zero or more exit points, as well as 
+  # the internal logic for the workflow.
+  #
+  #   Workflow.new do |w|
+  #     factor = w.config[:factor] || 1
+  #
+  #     t1 = Task.new {|task, input| input += 1 }
+  #     t2 = Task.new {|task, input| input += 10 }
+  #     t3 = Task.new {|task, input| input *= factor }
+  #   
+  #     w.app.sequence(t1, t2, t3)
+  #     w.entry_point = t1
+  #     w.exit_point = t3
+  #   end
+  #
+  # Or equivalently:
+  #
+  #   class SimpleSequence < Workflow
+  #     config :factor, 1
+  #
+  #     def workflow
+  #       t1 = Task.new {|task, input| input += 5 }
+  #       t2 = Task.new {|task, input| input += 3 }
+  #       t3 = Task.new {|task, input| input *= factor }
+  #   
+  #       app.sequence(t1, t2, t3)
+  #       self.entry_point = t1
+  #       self.exit_point = t3
+  #     end
+  #   end
+  #
+  # To facilitate the specification of entry and exit points, workflow
+  # can accomodate either single-task assignments or a collection.  By
+  # default both are hashes, but they can be reassigned:
   # 
-  # 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
+  #   Workflow.new do |w| 
+  #     w.entry_point.class                           # => Hash
+  #     w.exit_point.class                            # => Hash
+  #     w.entry_point[:main] = Task.new
+  #   end
+  #
+  #   Workflow.new {|w| w.entry_point = Task.new }
+  #   Workflow.new {|w| w.entry_point = [Task.new, Task.new] }
+  #
+  # Access to the group of entry/exit points is standardized to an
+  # array via the entry_points and exit_points methods.
+  #
+  # === Workflow Behavior
+  #
+  # The entry points act as an enque batch; when the workflow is enqued, the 
+  # entry points are enqued.  The exit points act as an on_complete batch; their
+  # on_complete blocks are set for workflow.on_complete.  
+  #
+  #   w = SimpleSequence.new
+  #   w.enq(0)
+  #   app.run
+  #   app.results(w.exit_points)                      # => [8]
+  #
+  # The batching of entry and exit points is distinct from workflow.batch itself. 
+  # Workflows can be batched like Tasks, such that all entry points from all 
+  # workflows in a batch are enqued at once. 
+  #
+  #   w1 = SimpleSequence.new nil, :factor => 1
+  #   w2 = w1.initialize_batch_obj nil, :factor => -1
+  #
+  #   w1.enq(0)
+  #   app.run
+  #   app.results(w1.exit_points, w2.exit_points))    # => [8, -8]
+  #
+  class Workflow 
+    include Support::Configurable
+    
+    # The entry point for self.
+    attr_accessor :entry_point
+    
+    # The exit point for self.
+    attr_accessor :exit_point
+    
+    # The task block provided during initialization.  
+    attr_reader :task_block
+    
+    # Creates a new Task with the specified attributes.
+    def initialize(name=nil, config={}, app=App.instance, &task_block)
+      @task_block = (task_block == nil ? default_task_block : task_block)
+      super(name, config, app)
+    end
+    
+    # Initializes a new batch object, running workflow to set the 
+    # instance-specific entry/exit points.  Raises an error if
+    # no entry points are defined.
+    def initialize_batch_obj(name=nil, config={})
+      task = super(name, config)
+      
+      task.entry_point = {}
+      task.exit_point = {}
+      task.workflow
       
-      self.entry_point = {}
-      self.exit_point = {}
-      self.workflow
+      raise WorkflowError.new("No entry points defined") if task.entry_points.empty?
       
+      task
+    end
+    
+    # Returns an array of entry points, determined from entry_point.
+    def entry_points
       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)
+      when Hash then entry_point.values
+      when Support::Executable then [entry_point]
+      when Array then entry_point
       else
-        raise WorkflowError.new("No entry point defined")
+        raise "unable to determine entry points from entry_point (should be Hash, Array, or Executable): #{entry_point}"
       end
     end
-
-    def sequence(*tasks)
-      app.sequence(*tasks)
+    
+    # Returns an array of exit points, determined from exit_point.
+    def exit_points
+      case exit_point
+      when Hash then exit_point.values
+      when Support::Executable then [exit_point]
+      when Array then exit_point
+      else
+        raise "unable to determine exit points from exit_point (should be Hash, Array, or Executable): #{exit_point}"
+      end
+    end
+    
+    # Enqueues all entry points for self and self.batch to app 
+    # with the inputs. The number of inputs provided should match 
+    # the number of inputs required by all the entry points;
+    # if the entry points have different input requirements, they
+    # have to be enqued separately.
+    def enq(*inputs)
+      batch.each {|t| t.unbatched_enq(*inputs) }
+      self
     end
     
-    def fork(source, *targets)
-      app.fork(source, *targets)
+    # Enques all entry points to app with the inputs.
+    def unbatched_enq(*inputs)
+      entry_points.each do |task|
+        app.enq(task, *inputs)
+      end
+      self
     end
     
-    def merge(target, *sources)
-      app.merge(target, *sources)
+    # Sets the on_complete_block for all exit points for self and 
+    # self.batch. Use unbatched_on_complete to set the on_complete_block
+    # for just self.exit_points.
+    def on_complete(override=false, &block)
+      batch.each {|t| t.unbatched_on_complete(override, &block)}
+      self
     end
     
+    # Sets the on_complete_block for all exit points for self.
+    def unbatched_on_complete(override=false, &block)
+      exit_points.each do |task|
+        task.on_complete(override, &block)
+      end
+      self
+    end
+
+    # The workflow definition method.  By default workflow
+    # simply calls the task_block.  In subclasses, workflow
+    # should be overridden to provide the workflow definition.
     def workflow
       raise WorkflowError.new("No workflow definition provided.") unless task_block
       task_block.call(self) 
     end
+
+    class WorkflowError < Exception # :nodoc:
+    end
     
-    def process(input)
-      input
+    # Returns the name of the workflow joined to the input.  This
+    # can be convenient when naming internal tasks, as they can 
+    # be grouped based on the name of the workflow.  Returns
+    # the name of the workflow if input == nil.
+    def name(input=nil)
+      input == nil ? @name : File.join(@name, input)
     end
     
-    class WorkflowError < Exception # :nodoc:
+    # Returns name
+    def to_s
+      name
+    end
+    
+    protected
+    
+    # Hook to set a default task block.  By default, nil.
+    def default_task_block
+      nil
     end
   end
 end

data/test/app/config/another/task.yml

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

data/test/app/config/erb.yml

@@ -1 +1,2 @@
-sum: <%= 1 + 2 %>
+app: <%= app.object_id %>
+filepath: <%= filepath %>

data/test/app/config/some/task.yml

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

data/test/app/config/template.yml

@@ -1,6 +1,2 @@
-default_field: default value
-
-variations!:
-  - field: item one
-  - field: item two
-    default_field: non-default value
+- factor: 10
+- factor: 22

data/test/app_test.rb

@@ -4,107 +4,225 @@ require 'stringio'
 require 'logger'
 
 class AppTest < Test::Unit::TestCase
-	include Tap
-	include TapTestMethods
-	
+  include Tap
+  include TapTestMethods
+  
   acts_as_tap_test
-	
-	def stub_gemspec(name, version)
-	  spec = Gem::Specification.new
-    spec.name = name
-    spec.version = version
-    spec.loaded_from = "/path/to/gems"
-    spec
-	end
-	
-	def test_app_documentation
-    task = Tap::Task.new {|task, input| input += 1 }
-    assert_equal Tap::App.instance, task.app
-    task.enq 1,2,3
-  
-    task.app.run      
-  
-    assert_equal [2,3,4], task.results.collect {|audit| audit._current}
-	end
-	
-	#
-	# App instance test
-	#
-	
-	def test_instance_returns_current_instance
-	  a = Tap::App.new
-	  Tap::App.instance = a
-	  assert_equal a, Tap::App.instance
-	end
-	
-	def test_instance_initializes_new_App_if_not_set
-	  Tap::App.instance = nil
-	  assert Tap::App.instance.kind_of?(Tap::App)
-	end
-	
-	#
-	# App parse_yaml test
-	#
-	
-	def test_parse_yaml_documentation
-    str = {'key' => 'value'}.to_yaml
-    assert_equal "--- \nkey: value\n", str
-    assert_equal({'key' => 'value'}, Tap::App.parse_yaml(str))
-    assert_equal "str", Tap::App.parse_yaml("str")
-	end
-	
-	def test_parse_yaml_parses_correctly_formatted_strings
-    assert_equal({'key' => 'value'}, Tap::App.parse_yaml("---\nkey: value"))
-	end
-	
-	def test_parse_yaml_returns_strings_not_matching_yaml_format
-    assert_equal("str", Tap::App.parse_yaml("str"))
-	end
-	
-	#
-	# App read_erb_yml test
-	#
-	
-	def test_read_erb_yaml_templates_file_using_erb_then_loads_as_yaml
-	  file = tempfile
-	  File.open(file, "w") do |f|
-	    f << %Q{
-<% value = "value" %>
-<%= "k" + "ey" %>: <%= value %>}
-	  end
-	  
-	  assert_equal({'key' => 'value'}, Tap::App.read_erb_yaml(file))
-	end
-	
-	def test_read_erb_yaml_returns_nil_if_filepath_does_not_exist_or_is_a_dir
-	  file = File.dirname(__FILE__) + "/app/no_existant_file.txt"
-	  dir = File.dirname(__FILE__) + "/app"
-	  
-    assert !File.exists?(file)
-    assert File.directory?(dir)
-    assert_nil Tap::App.read_erb_yaml(file)
-    assert_nil Tap::App.read_erb_yaml(dir)
-	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
+  
+  def setup
+    super
+    app.root = trs.root
+  end
+  
+  #
+  # 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
+  
+  def test_instance_initializes_new_App_if_not_set
+    Tap::App.instance = nil
+    assert Tap::App.instance.kind_of?(Tap::App)
+  end
+  
+  #
+  # helpers
+  #
+  
+  # def stub_gemspec(name, version)
+  #   spec = Gem::Specification.new
+  #   spec.name = name
+  #   spec.version = version
+  #   spec.loaded_from = "/path/to/gems"
+  #   spec
+  # end
+  
+  def current_threads
+    threads =  []
+    ObjectSpace.garbage_collect
+    sleep 0.2 # sleep to give garbage collect time to run
+    
+    # JRuby limits ObjectSpace to only work for Class by default
+    # so this line has to be made less elegant and a little slower
+    #   ObjectSpace.each_object(Thread) {|t| threads << t.object_id}
+    ObjectSpace.each_object(Class) {|t| threads << t.object_id if t.kind_of?(Thread)}
+    threads
+  end
+  
+  # check that no new threads are created during the block
+  def extended_test_with_thread_check
+    extended_test do
+      prior_threads = current_threads
+      yield
+      assert_equal prior_threads, current_threads
+    end
+  end
+
+  def test_app_documentation
+    pwd = app.root
+    assert_equal(pwd, app.root)
+    assert_equal( File.expand_path(pwd +'/config'), app[:config])
+  
+    some_task = Task.new 'some/task'
+    assert_equal( App.instance , some_task.app )
+    assert_equal( File.expand_path(pwd +'/config/some/task.yml') , some_task.config_file)
+    assert_equal( {:key => 'one'}, some_task.config)
+  
+    another_task = Task.new 'another/task'
+    assert_equal( App.instance , another_task.app )
+    assert_equal( File.expand_path(pwd + '/config/another/task.yml') , another_task.config_file)
+    assert_equal( {:key => 'two'}, another_task.config)
+
+    ###
+    t1 = Task.new {|task, input| input += 1 }
+    t1.enq 0
+    t1.enq 10
+  
+    app.run
+    assert_equal [1, 11], app.results(t1)
+  
+    app.aggregator.clear
+  
+    t2= Task.new {|task, input| input += 10 }
+    t1.on_complete {|_result| t2.enq(_result) }
+  
+    t1.enq 0
+    t1.enq 10
+  
+    app.run
+    assert_equal [], app.results(t1)
+    assert_equal [11, 21], app.results(t2)
+  
+    ###
+    t1 = Task.new  {|task, input| input += 1 }
+    t2 = Task.new  {|task, input| input += 10 }
+    assert_equal [t1, t2], Task.batch(t1, t2)
+  
+    t1.enq 0
+    t2.enq 10
+  
+    app.run
+    assert_equal [1, 11], app.results(t1)
+    assert_equal [10, 20], app.results(t2)
+  
+    lock = Mutex.new
+    array = []
+    t1 = Task.new  {|task| lock.synchronize { array << Thread.current.object_id }; sleep 0.1 }
+    t2 = Task.new  {|task| lock.synchronize { array << Thread.current.object_id }; sleep 0.1 }
+  
+    t1.multithread = true
+    t1.enq
+    t2.multithread = true
+    t2.enq
+    
+    app.run
+    assert_equal 2, array.length
+    assert_not_equal array[0], array[1]
+    
+    array = []
+    Task::Base.initialize(array, :push)
+  
+    array.enq(1)
+    array.enq(2)
+  
+    assert array.empty?
+    app.run
+    assert_equal [1, 2], array
+  
+    array = []
+    m = array._method(:push)
+   
+    app.enq(m, 1)
+    app.mq(array, :push, 2)
+
+    assert array.empty?
+    app.run
+    assert_equal [1, 2], array
+
+    ###
+    t1 = Tap::Task.new('add_one') {|task, input| input += 1 }
+    t2 = Tap::Task.new('add_five') {|task, input| input += 5 }
+
+    t1.on_complete do |_result|
+      _result._current < 3 ? t1.enq(_result) : t2.enq(_result)
+    end
+  
+    t1.enq(0)
+    t1.enq(1)
+    t1.enq(2)
+
+    app.run
+    assert_equal [8,8,8], app.results(t2)
+
+    strio = StringIO.new("")
+    app._results(t2).each do |_result|
+      strio.puts "How #{_result._original} became #{_result._current}:"
+      strio.puts _result._to_s
+      strio.puts
+    end
+
+    assert_equal(
+%Q{How 2 became 8:
+o-[] 2
+o-[add_one] 3
+o-[add_five] 8
+
+How 1 became 8:
+o-[] 1
+o-[add_one] 2
+o-[add_one] 3
+o-[add_five] 8
+
+How 0 became 8:
+o-[] 0
+o-[add_one] 1
+o-[add_one] 2
+o-[add_one] 3
+o-[add_five] 8
+
+}, strio.string)
+
+  end
+  
+  #
+  #  State test
+  #
+  
+  def test_state_str_documentation
+    assert_equal 'READY', App::State.state_str(0)
+    assert_nil App::State.state_str(12)
+  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(Support::ExecutableQueue, app.queue.class)
+    assert app.queue.empty?
+    assert_equal(Support::Aggregator, app.aggregator.class)
+    assert app.aggregator.empty?
+    assert_equal App::State::READY, app.state
+  end
+  
+  #
+  # task config tests
+  #
+  
+  def test_config_returns_current_configurations
     app = App.new
     expected = {
       :root => Dir.pwd,
@@ -155,7 +273,7 @@ class AppTest < Test::Unit::TestCase
     assert_equal File.expand_path("./new/root/path/to/dir"), app[:dir]          
     assert_equal Logger::DEBUG, app.logger.level   
   end
-	
+  
   def test_reconfigure_root_sets_app_root
     app = App.new
     
@@ -219,8 +337,11 @@ class AppTest < Test::Unit::TestCase
   
   class AppHandlesConfig < App
     attr_accessor :handled_configs
+    def initialize
+      self.handled_configs = []
+    end
     def handle_configuation(key, value)
-      (self.handled_configs ||= []).concat [key, value]
+      handled_configs.concat [key, value]
       true
     end
   end
@@ -237,7 +358,7 @@ class AppTest < Test::Unit::TestCase
   
   class AppDoesNotHandleConfig < AppHandlesConfig
     def handle_configuation(key, value)
-      (self.handled_configs ||= []).concat [key, value]
+      handled_configs.concat [key, value]
       false
     end
   end
@@ -251,27 +372,61 @@ class AppTest < Test::Unit::TestCase
     assert_equal [:unknown, 'value'], app.handled_configs
     assert was_in_block
   end
+  
+  #
+  # reload test
+  #
+  
+  def test_reload_returns_unloaded_constants
+    app = Tap::App.instance
+    
+    Dependencies.clear
+    assert_equal [], app.reload
+    
+    begin
+      assert !Object.const_defined?("AppTestTask")
+      
+      Dependencies.load_paths << app['lib']
+      app_task_test_mod = AppTestTask
+      
+      assert Object.const_defined?("AppTestTask")
+      assert_equal [:AppTestTask], app.reload.collect {|c| c.to_sym }
+      assert !Object.const_defined?("AppTestTask")
+    ensure
+      Dependencies.clear
+      Dependencies.load_paths.delete(app['lib'])
+    end
+  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
-	#
+  #
+  # lookup_const test
+  #
+  
+  def test_lookup_const_does_not_mishandle_top_level_constants
+    assert !Object.const_defined?('LookupModule')
+    Object.const_set('LookupModule', Module.new)
+    assert_raise(Tap::App::LookupError) { app.lookup_const('lookup_module/file') }
+  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
+  # task_class tests
   #
   
   class TaskSubClass < Task
@@ -280,11 +435,28 @@ class AppTest < Test::Unit::TestCase
   class AnotherTask < Task
   end
   
+  def test_task_class_documentation
+    t_class = app.task_class('tap/file_task')
+    assert_equal Tap::FileTask, t_class
+  
+    app.map = {"mapped-task" => "Tap::FileTask"}
+    t_class = app.task_class('mapped-task-1.0')
+    assert_equal Tap::FileTask, t_class
+  end
+  
+  #
+  # task tests
+  #
+  
   def test_task_documentation
-    app.map = {"mapped-task" => "AppTest::AnotherTask"}
+    t = app.task('tap/file_task')
+    assert_equal  Tap::FileTask, t.class      
+    assert_equal 'tap/file_task', t.name 
+
+    app.map = {"mapped-task" =>  "Tap::FileTask"}
   
     t = app.task('mapped-task-1.0', :key => 'value')
-    assert_equal AnotherTask, t.class      
+    assert_equal  Tap::FileTask, t.class      
     assert_equal "mapped-task-1.0", t.name 
     assert_equal 'value', t.config[:key]
   end
@@ -317,9 +489,15 @@ class AppTest < Test::Unit::TestCase
   
   def test_task_looks_up_task_classes_along_Dependencies_load_paths
     begin
+      assert !Object.const_defined?("AppTestTask")
+      
       Dependencies.load_paths << app['lib']
-      assert_equal AppTestTask, app.task("AppTestTask").class
+      t = app.task("AppTestTask")
+      
+      assert Object.const_defined?("AppTestTask")
+      assert_equal AppTestTask, t.class
     ensure
+      Dependencies.clear
       Dependencies.load_paths.delete(app['lib'])
     end
   end
@@ -333,10 +511,15 @@ class AppTest < Test::Unit::TestCase
   #
   
   def test_task_class_name_documentation
-    t = Task.new
-    app.map = {"mapped-task" => "AnotherTask"}
-    assert_equal "Tap::Task", app.task_class_name(t)              
-    assert_equal "AnotherTask", app.task_class_name('mapped-task-1.0')   
+    app.map = {"mapped-task" => "Tap::FileTask"}
+    assert_equal "some/task_class", app.task_class_name('some/task_class')   
+    assert_equal "Tap::FileTask", app.task_class_name('mapped-task-1.0')   
+    
+    t1 = Task.new
+    assert_equal "Tap::Task", app.task_class_name(t1)     
+
+    t2 = ObjectWithExecute.new.extend Tap::Task::Base
+    assert_equal "ObjectWithExecute", app.task_class_name(t2)    
   end
   
   def test_task_class_name_returns_task_class_name
@@ -346,13 +529,13 @@ class AppTest < Test::Unit::TestCase
     subtask = TaskSubClass.new
     assert_equal "AppTest::TaskSubClass", app.task_class_name(subtask)
     
-    non_task = Object.new
+    non_task = ObjectWithExecute.new
     non_task.extend Tap::Task::Base
-    assert_equal "Object", app.task_class_name(non_task)
+    assert_equal "ObjectWithExecute", app.task_class_name(non_task)
   end
 
-  def test_task_class_name_returns_deversioned_camelized_name
-    assert_equal "AppTest::TaskSubClass", app.task_class_name("app_test/task_sub_class-1.1")
+  def test_task_class_name_returns_deversioned_name
+    assert_equal "app_test/task_sub_class", app.task_class_name("app_test/task_sub_class-1.1")
   end
   
   def test_task_class_name_resolves_names_using_map
@@ -361,145 +544,185 @@ class AppTest < Test::Unit::TestCase
   end
   
   #
-	# config_templates tests
-	#
+  # each_config_template tests
+  #
   
-  def test_config_templates_documentation
-    simple = tempfile
+  def test_each_config_template_documentation
+    simple = output_tempfile
     File.open(simple, "w") {|f| f <<  "key: value"}
-    assert_equal([{"key" => "value"}], app.config_templates(simple))
+    assert_equal([{"key" => "value"}], app.each_config_template(simple))
   
-    array_with_erb = tempfile
-    File.open(array_with_erb, "w") do |f| 
+    erb = output_tempfile
+    File.open(erb, "w") {|f| f <<  "app: <%= app.object_id %>\nfilepath: <%= filepath %>"}
+    assert_equal([{"app" => app.object_id, "filepath" => erb}], app.each_config_template(erb))
+  
+    batched_with_erb = output_tempfile
+    File.open(batched_with_erb, "w") do |f| 
       f << %Q{ 
 - key: <%= 1 %>
 - key: <%= 1 + 1 %>}
     end
-    assert_equal([{"key" => 1}, {"key" => 2}], app.config_templates(array_with_erb))
-  end
-  
-	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
+    assert_equal([{"key" => 1}, {"key" => 2}], app.each_config_template(batched_with_erb))
+  end
+  
+  def test_each_config_template_retrieves_templates_for_versioned_config_files
+    filepath = app.filepath('config', "version.yml")
+    assert File.exists?(filepath)
+    assert_equal [{"version" => "empty"}], app.each_config_template(filepath)
+    
+    filepath = app.filepath('config', "version-0.1.yml")
+    assert File.exists?(filepath)
+    assert_equal [{"version" => 0.1}], app.each_config_template(filepath)
+  end
+  
+  def test_each_config_template_can_load_an_array_of_templates  
+    filepath = app.filepath('config', "batch.yml")
+    assert File.exists?(filepath)
+    assert_equal [{"key" => "one"}, {"key" => "two"}], app.each_config_template(filepath)
+  end
 
-	def test_config_templates_returns_empty_template_even_if_config_file_does_not_exist
+  def test_each_config_template_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)
+    assert_equal [{}], app.each_config_template(filepath)
   end
   
-  def test_config_templates_returns_empty_template_if_config_file_is_empty
+  def test_each_config_template_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)
+    assert_equal [{}], app.each_config_template(filepath)
   end
   
-  def test_config_templates_templates_using_erb
-	  filepath = app.filepath('config', "erb.yml")
-  	assert_equal [{"sum" => 3}], app.config_templates(filepath)
-	end
+  def test_each_config_template_templates_using_erb
+    filepath = app.filepath('config', "erb.yml")
+    assert_equal [{"filepath" => filepath, "app" => app.object_id}], app.each_config_template(filepath)
+  end
   
   #
-  # execute test
+  # config_filepath 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
+  def test_config_filepath
+    assert_equal nil, app.config_filepath(nil)
+    assert_equal File.join(app['config'], "task/name.yml"), app.config_filepath("task/name")
+  end
+  
+  #
+  # ready test
+  #
+  
+  def test_ready_sets_state_to_READY_unless_running
+    app.instance_variable_set('@state', App::State::STOP)
+    assert_not_equal App::State::READY, app.state
+    
+    assert_equal app, app.ready
+    assert_equal App::State::READY, app.state
+  end
+  
+  def test_ready_does_not_sets_state_to_READY_when_running
+    was_in_block = false
+    
+    t = Tap::Task.new do |task|
+      assert_equal App::State::RUN, app.state
+      task.app.ready
+      assert_equal App::State::RUN, app.state
+      
+      task.app.stop
+      assert_equal App::State::STOP, app.state
+      task.app.ready
+      assert_equal App::State::STOP, app.state
+      
+      was_in_block = true
+    end
+    
+    with_options :debug => true do
+      t.enq
+      app.run
+    end
+    
+    assert was_in_block
+  end
+  
+  #
+  # run tests
+  #
+
+  def test_run_single_task
+    t = Task.new(&add_one)
+    with_options :debug => true do
+      t.enq 1
+      app.run
+    end
+    
+    assert_audit_equal(ExpAudit[[nil, 1], [t,2]], app._results(t).first)
+    assert_equal [1], runlist
+  end
   
-	#
-	# run tests
-	#
+  def test_run_single_task_from_a_thread
+    t = Task.new(&add_one)
+    with_options :debug => true do
+      t.enq 1
+      th = Thread.new { app.run }
+      th.join
+    end
 
-	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
-	#
+    assert_audit_equal(ExpAudit[[nil, 1], [t,2]], app._results(t).first)
+    assert_equal [1], runlist
+  end
+  
+  #
+  # multithread test
+  #
   
   def test_main_thread_execution_waits_for_multithread_execution
     extended_test do
       main_thread_ran = false
+      check_thread_ran = false
       multithread_ran = false
       
       multithread_executing = false
       main_thread_did_not_wait = false
+      multithread_did_not_wait = false
     
-	    t1 = Task.new do |task, input|
+      t1 = Task.new do |task|
         main_thread_ran = true
         main_thread_did_not_wait = true if multithread_executing
       end
     
-	    t2 = Task.new do |task, input|
+      t2 = Task.new do |task|
+        check_thread_ran = true
+        multithread_did_not_wait = true if multithread_executing
+      end
+      t2.multithread = true
+      
+      t3 = Task.new do |task|
         multithread_ran = true
         multithread_executing = true
       
         # sleep is necessary so the other threads
         # have an opportunity to execute
-        sleep(0.2) 
+        sleep(0.1) 
         
         multithread_executing = false
       end
-      t2.multithread = true
+      t3.multithread = true
       
-      t2.enq nil
-      t1.enq nil
+      t3.enq
+      t2.enq
+      t1.enq
       
-      app.run
+      with_options :debug => true do
+        app.run
+      end
       
       assert main_thread_ran
       assert multithread_ran
+      assert check_thread_ran
       assert !main_thread_did_not_wait
+      assert multithread_did_not_wait
     end
-	end
+  end
   
   def test_multithread_execution_waits_for_main_thread_execution
     extended_test do
@@ -509,430 +732,326 @@ class AppTest < Test::Unit::TestCase
       multithread_did_not_wait = false
       main_thread_executing = false
     
-	    t1 = Task.new do |task, input|
+      t1 = Task.new do |task|
         multithread_ran = true
         multithread_did_not_wait = true if main_thread_executing
       end
       t1.multithread = true
-    
-	    t2 = Task.new do |task, input|
+      
+      t2 = Task.new do |task|
         main_thread_ran = true
         main_thread_executing = true
       
         # sleep is necessary so the other threads
         # have an opportunity to execute
-        sleep(0.2) 
+        sleep(0.1) 
         
         main_thread_executing = false
       end
       
-      t1.enq nil
-      t2.enq nil
+      t2.enq
+      t1.enq
       
-      app.run
+      with_options :debug => true do
+        app.run
+      end
       
       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 = []
+  end
+  
+  def test_only_max_threads_will_be_executed_at_a_time
+    extended_test do
+      max_threads = 0
+      n_threads = 0
       
-			# 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
+      # 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 |task|
+        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) 
+        sleep(0.1) 
         
-				n_threads -= 1
-				nil
-			end
+        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
-	
-  # inconsistent test ruby, windows
-	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
-	  
-    # JRuby limits ObjectSpace to only work for Class by default
-	  # so this line has to be made less elegant and a little slower
-	  #   ObjectSpace.each_object(Thread) {|t| threads << t.object_id}
-	  ObjectSpace.each_object(Class) {|t| threads << t.object_id if t.kind_of?(Thread)}
-	  threads
-	end
-	
-	def extended_test_with_thread_check
-	  extended_test do
-  	  prior_threads = current_threads
-  	  yield
-  	  assert_equal prior_threads, current_threads
+      t1 = Task.new(&block)
+      t2 = Task.new(&block)
+      t3 = Task.new(&block)
+      
+      with_options(:max_threads => 2) do
+        [t1,t2,t3].each do |t|
+          t.enq
+          t.multithread = true
+        end
+     
+        with_options :debug => true do
+          app.run
+        end
+      
+        assert_equal 2, max_threads
+      end
     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
+  
+  def test_no_new_threads_appear_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|
+          n_threads += 1
+          max_threads = n_threads if n_threads > max_threads
+          sleep 0.1
+          n_threads -= 1
         end 
       end
       tasks.each do |task|
         task.multithread = true
-        task.enq nil
+        task.enq
       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
+  
+  # JRuby inconsistent test?
+  # 2 max_threads expected but was 1
+  def test_no_new_threads_appear_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|
+          n_threads += 1
+          max_threads = n_threads if n_threads > max_threads
+          sleep 0.1
+          n_threads -= 1
         end 
       end
       non_threaded = tasks.shift
       tasks.each do |task|
         task.multithread = true
-        task.enq nil
+        task.enq
       end
-      non_threaded.enq nil
+      non_threaded.enq
       
       app.run
     
       assert_equal 2, max_threads
-	  end
-	end
+    end
+  end
 
-  
   #
   # stop test
   #
   
   def test_stop_prevents_non_executing_tasks_from_executing_on_main_thread
-    extended_test do
+    extended_test_with_thread_check do
       count = 0
       tasks = Array.new(5) do
-        Task.new do |task, inputs|
+        Task.new do |task|
           count += 1
           app.stop if count == 2
         end 
       end
-  		tasks.each do |task| 
-  		  task.enq nil
-  		end
+      tasks.each do |task| 
+        task.enq
+      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
+      # 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, :debug => true  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
+      end
+    
+      # check that the requeued tasks are in order
+      assert_equal tasks[2...5], queued_tasks
+    end
   end
   
   def test_stop_prevents_non_executing_tasks_from_executing_on_threads_and_requeues_thread_queue
-    extended_test do
+    extended_test_with_thread_check do
       count = 0
       tasks = Array.new(5) do
-        Task.new do |task, inputs|
+        Task.new do |task|
           count += 1
-          sleep 0.2
+          sleep 0.1
           app.stop if count == 2
-          sleep 0.2
+          sleep 0.1
         end 
       end
-  		tasks.each do |task| 
-  		  task.multithread = true
-  		  task.enq nil
-  		end
+      tasks.each do |task| 
+        task.multithread = true
+        task.enq
+      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
+      # 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, :debug => true 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
+      end
+    
+      # check that the requeued tasks are in order
+      assert_equal tasks[2...5], queued_tasks
+    end
   end
 
   #
   # terminate test
   #
   
-  # TODO -- REWORD
   def test_terminate_from_main_thread_raises_run_error
-    extended_test do
-      was_not_terminated = false
-      task = Task.new do |task, inputs|
+    extended_test_with_thread_check do
+      was_terminated = true
+      task = Task.new do |t|
         app.terminate
-        task.check_terminate
-        was_not_terminated = true
+        t.check_terminate
+        was_terminated = false
       end
       
-      task.enq nil
+      task.enq
       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?
+          assert $!.errors.empty?
         end
       end
-    	
-		  assert !was_not_terminated
-  	end
+      
+      assert was_terminated
+    end
   end
 
-  # TODO -- REWORD
   def test_terminate_from_main_thread_when_error_is_handled_still_raises_error
-    extended_test do
+    extended_test_with_thread_check do
       terminate_error_handled = false
-      task = Task.new do |task, inputs|
+      task = Task.new do |t|
         begin
           app.terminate
-          task.check_terminate
+          t.check_terminate
         rescue
           terminate_error_handled = true
         end
       end
       
-      task.enq nil
+      task.enq
       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?
+          assert $!.errors.empty?
         end
       end
-    	
-		  assert terminate_error_handled
-  	end
+      
+      assert terminate_error_handled
+    end
   end
 
-  # TODO -- REWORD
   def test_terminate_raises_error_on_each_execution_thread_and_requeues_thread_queue
-    extended_test do
+    extended_test_with_thread_check do
       count = 0
       some_thread_was_not_terminated = false
       tasks = Array.new(5) do
-        Task.new do |task, inputs|
+        Task.new do |task|
           count += 1
           app.terminate if count == 2
-          sleep 1
+          sleep 0.8
           task.check_terminate
           some_thread_was_not_terminated = true
         end 
       end
-  		tasks.each do |task| 
-  		  task.multithread = true
-  		  task.enq nil
-  		end
+      tasks.each do |task| 
+        task.multithread = true
+        task.enq
+      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
+      # 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?
+          assert $!.errors.empty?
         end
-    	end
-    	
-  		assert_equal 2, count
-  		assert_equal 3, app.queue.size
-		  assert !some_thread_was_not_terminated
+      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
+      queued_tasks = []
+      while !app.queue.empty?
+        task, inputs = app.queue.deq
+        queued_tasks << task
+      end
+    
+      # check that the requeued tasks are in order
+      assert_equal tasks[2...5], queued_tasks
+    end
   end
 
-  # TODO -- REWORD
   # JRuby inconsistent test
+  # RESOLVED? 2008/01/29
+  # -- still can be an issue, if the sleep time is too short -- 
   def test_terminate_on_thread_when_error_is_handled_still_raises_error
-    extended_test do
+    extended_test_with_thread_check do
       count = 0
       some_thread_was_not_terminated = false
       handled_count = 0
       
       tasks = Array.new(5) do
-        Task.new do |task, inputs|
+        Task.new do |task|
           count += 1
           begin
             app.terminate if count == 2
-            sleep 1
+            sleep 0.8
             task.check_terminate
             some_thread_was_not_terminated = true
           rescue
@@ -940,31 +1059,30 @@ class AppTest < Test::Unit::TestCase
           end
         end 
       end
-  		tasks.each do |task| 
-  		  task.multithread = true
-  		  task.enq nil
-  		end
+      tasks.each do |task| 
+        task.multithread = true
+        task.enq
+      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
+      # 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?
+          assert $!.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
+      
+      assert !some_thread_was_not_terminated
+      assert_equal 2, count
+      assert_equal 2, handled_count
+      assert_equal 3, app.queue.size
     end
   end
 
@@ -973,477 +1091,567 @@ class AppTest < Test::Unit::TestCase
   #
   
   def test_info_provides_information_string
-    assert_equal 'state: 0 (READY) queue: 0 waiting: 0 (0) threads: 0', app.info
+    assert_equal 'state: 0 (READY) queue: 0 thread_queue: 0 threads: 0 results: 0', app.info
   end
 
   # TODO -- JRuby inconsistent test
+  # RESOLVED? 2007/01/30
   def test_info_can_be_called_during_a_run
     extended_test do
+      lock = Monitor.new
       count = 0
       info_str = nil
       
       tasks = Array.new(5) do
-        Task.new do |task, inputs|
-          count += 1
-          if count == 2
-            info_str = app.info 
-            app.stop
+        Task.new do |task|
+          
+          lock.synchronize do
+            count += 1
+            if count == 2
+              info_str = app.info 
+              app.stop
+            end
           end
-          sleep 2
+          
+          sleep 0.8
         end 
       end
-  		tasks.each do |task| 
-  		  task.enq nil
-  		  task.multithread = true
-  		end
-  		
-  		with_options :max_threads => 2 do
+      tasks.each do |task| 
+        task.enq
+        task.multithread = true
+      end
+      
+      with_options :max_threads => 2 do
         app.run
-    	end
-    	
-      # There is some ambiguity in the info string  -- threads could be 
-      # waiting in the queue or in the thread queue, but their sum must be 3
-      # Regexp patterned from 'state: 1 (RUN) queue: 3 waiting: 3 (0) threads: 2'
-    	assert info_str =~ /state: 1 \(RUN\) queue: 3 waiting: (\d) \((\d)\) threads: 2/, info_str  
-      assert_equal 3, $1.to_i + $2.to_i
-    	assert_equal 'state: 0 (READY) queue: 3 waiting: 3 (0) threads: 0', app.info
-  	end
+      end
+      
+      # There is some ambiguity in the info string  -- tasks 
+      # could be waiting in the queue or in the thread queue
+      # and additionally, the thread queue may have nils to
+      # signal the threads to terminate
+      assert info_str =~ /state: 1 \(RUN\) queue: \d thread_queue: \d threads: 2 results: \d/, info_str  
+      assert_equal 'state: 0 (READY) queue: 3 thread_queue: 0 threads: 0 results: 2', app.info
+    end
+  end
+  
+  #
+  # enq test
+  #
+  
+  def test_enq
+    t = Task.new
+    assert app.queue.empty?
+    app.enq(t)
+    assert_equal [[t, []]], app.queue.to_a
+  end
+  
+  def test_enq_enques_each_task_in_task_batch
+    t1 = Task.new
+    t2 = t1.initialize_batch_obj
+    
+    assert app.queue.empty?
+    app.enq(t1)
+    assert_equal [[t1, []], [t2, []]], app.queue.to_a
+  end
+  
+  def test_enq_allows_methods
+    m = []._method(:push)
+    assert app.queue.empty?
+    app.enq(m)
+    assert_equal [[m, []]], app.queue.to_a
+  end
+  
+  def test_enq_returns_enqued_task
+    t = Task.new
+    assert_equal t, app.enq(t)
+  end
+  
+  #
+  # mq test
+  #
+  
+  def test_mq
+    a = []
+    assert app.queue.empty?
+    m = app.mq(a, :push, 1, 2)
+    assert_equal [[m, [1,2]]], app.queue.to_a
   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
+#   #
+#   # 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 |result|
+#       t2.enq result
+#       t3.enq result
+#     end
+#     with_options :debug => true do
+#       t1.enq 0
+#       app.run
+#     end
+# 
+#     assert_equal [0,1,1], runlist
+#     assert_audit_equal(ExpAudit[[nil,0],[t1,1],[t2,2]], app._results(t2).first)
+#     assert_audit_equal(ExpAudit[[nil,0],[t1,1],[t3,2]], app._results(t3).first)
+#   end
+    
+  #
+  # sequence tests
+  #
+  
+  def test_run_sequence
+    t1 = Task.new(&add_one)
+    t2 = Task.new(&add_one)
+    
+    app.sequence(t1,t2)
+    with_options :debug => true do
+      t1.enq 0
+      app.run
     end
+    
+    assert_equal [0,1], runlist
+    assert_audit_equal(ExpAudit[[nil,0],[t1,1],[t2,2]], app._results(t2).first)
+  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_sequence_from_trailing_task
+    t1 = Task.new(&add_one)
+    t2 = Task.new(&add_one)
+    
+    app.sequence(t1,t2)
+    with_options :debug => true do
+      t2.enq 1
+     app.run
+    end
+    
+    assert_equal [1], runlist
+    assert_equal 0, app._results(t1).length
+    assert_audit_equal(ExpAudit[[nil,1],[t2,2]], app._results(t2).first)
+  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
-	
-	# TODO -- JRuby inconsistent test
-	def test_multithread_batched_tasks_execute_cosynchronously
+  #
+  # 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)
+    with_options :debug => true do
+      t1.enq 0
+      app.run
+    end
+  
+    assert_equal [0,1,1], runlist
+    assert_audit_equal(ExpAudit[[nil,0],[t1,1],[t2,2]], app._results(t2).first)
+    assert_audit_equal(ExpAudit[[nil,0],[t1,1],[t3,2]], app._results(t3).first)
+  end
+  
+  #
+  # merge tests
+  #
+  
+  def test_run_merge
+    t1 = Task.new(&add_one)
+    t2 = Task.new(&add_one)
+    t3 = Task.new(&add_one)
+  
+    app.merge(t3, t1, t2)
+    with_options :debug => true do
+      t1.enq 0
+      t2.enq 10
+      app.run
+    end
+    
+    assert_equal [0,10,1,11], runlist
+    
+    assert_audits_equal([
+      ExpAudit[[nil,0],[t1,1],[t3,2]],
+      ExpAudit[[nil,10],[t2,11],[t3,12]]
+    ], app._results(t3))
+  end
+  
+   #
+   # run batched task tests
+   #
+   
+   def test_run_batched_task
+     t1 = Task.new('template') do |task, input|
+       runlist << input
+       input + task.config[:factor]
+     end
+     assert_equal 2, t1.batch.length
+     
+     t1_0 = t1.batch[0]
+     t1_1 = t1.batch[1]
+     
+     assert_equal 10, t1_0.config[:factor]
+     assert_equal 22, t1_1.config[:factor]
+     
+     with_options :debug => true do
+       t1.enq 0
+       app.run
+     end
+     
+     # note same input fed to each template 
+     assert_equal [0,0], runlist
+     
+     assert_audits_equal([
+       ExpAudit[[nil,0],[t1_0,10]],
+       ExpAudit[[nil,0],[t1_1,22]]
+     ], app._results(*t1.batch))
+   end
+   
+  def test_run_batched_task_with_existing_audit_trails
+    t1 = Task.new('template') do |task, input|
+      runlist << input
+      input + task.config[:factor]
+    end
+    assert_equal 2, t1.batch.length
+    
+    t1_0 = t1.batch[0]
+    t1_1 = t1.batch[1]
+    
+    assert_equal 10, t1_0.config[:factor]
+    assert_equal 22, t1_1.config[:factor]
+    
+    a = Support::Audit.new(0, :a)
+    with_options :debug => true do
+      t1.enq a
+      app.run
+    end
+    
+    # note same input fed to each template 
+    assert_equal [0,0], runlist
+    
+    assert_audits_equal([
+      ExpAudit[[:a,0],[t1_0,10]],
+      ExpAudit[[:a,0],[t1_1,22]]
+    ], app._results(t1.batch))
+  end
+  
+  # TODO -- JRuby inconsistent test
+  # RESOLVED? 2007/01/30
+  def test_multithread_batched_tasks_execute_cosynchronously
     extended_test do
+      lock = Monitor.new
       max_threads = 0
-			n_threads = 0
-			
-			block = lambda do
-				n_threads += 1
-				max_threads = n_threads if n_threads > max_threads
+      n_threads = 0
+      
+      block = lambda do |task|
+        lock.synchronize do
+          n_threads += 1
+          max_threads = n_threads if n_threads > max_threads
+        end
         
         # sleep is necessary so the other threads
         # have an opportunity to execute
-				sleep(1) 
- 
-				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
+        sleep(0.1) 
+   
+        lock.synchronize { n_threads -= 1 }
+        nil
+      end
+      
+      t1 = Task.new(&block)
+      t1.initialize_batch_obj
+      
+      assert_equal 2, t1.batch.length
+      t1.multithread = true
+      t1.enq
+  
+      with_options :debug => true do
+        app.run
+      end
+      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)
-
+  end
+  
+  def test_fork_in_batched_task
+    t1, t2, t3 = Array.new(3) do
+      t = Task.new(nil, :factor => 10) do |task, input|
+        runlist << input
+        input + task.config[:factor]
+      end
+      t.initialize_batch_obj(nil, :factor => 22)
+    end
+    
+    app.fork(t1, t2, t3)
+    with_options :debug => true do
+      t1.enq 0
+      app.run
+    end
+    
+    assert_equal [
+      0,0,             # once for each t1 template
+      10,10, 10,10,    # first result into t2, t3 tasks
+      22,22, 22,22     # second result into t2, t3 tasks
+    ], 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] 
+    t3_1 = t3.batch[1]
+    
+    # check t2 results
+    assert_audits_equal([
+      ExpAudit[[nil,0],[t1_0,10],[t2_0,20]],
+      ExpAudit[[nil,0],[t1_1,22],[t2_0,32]],
+      ExpAudit[[nil,0],[t1_0,10],[t2_1,32]],
+      ExpAudit[[nil,0],[t1_1,22],[t2_1,44]]
+    ], app._results(t2.batch))
+    
+    # check t3 results
+    assert_audits_equal([
+      ExpAudit[[nil,0],[t1_0,10],[t3_0,20]],
+      ExpAudit[[nil,0],[t1_1,22],[t3_0,32]],
+      ExpAudit[[nil,0],[t1_0,10],[t3_1,32]], 
+      ExpAudit[[nil,0],[t1_1,22],[t3_1,44]]
+    ], app._results(t3.batch))
+  end
+  
+  def test_merge_batched_task
+    t1, t2, t3 = Array.new(3) do
+      t = Task.new(nil, :factor => 10) do |task, input|
+        runlist << input
+        input + task.config[:factor]
+      end
+      t.initialize_batch_obj(nil, :factor => 22)
+    end
+  
+    app.merge(t3, t1, t2)
+    t1.enq(0)
+    t2.enq(2)
+    with_options :debug => true do
+      app.run
+    end
+  
+    assert_equal [
+      0,0,                  # 1 input to each t1
+      2,2,                  # 2 input to each t2
+      10,10,22,22,          # t1 outputs to each t3
+      12,12,24,24           # t2 outputs to each 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] 
+    t3_1 = t3.batch[1]
+  
+    # check results
+    assert_audits_equal([
+      ExpAudit[[nil,0],[t1_0,10],[t3_0,20]], 
+      ExpAudit[[nil,0],[t1_1,22],[t3_0,32]],
+      ExpAudit[[nil,2],[t2_0,12],[t3_0,22]],
+      ExpAudit[[nil,2],[t2_1,24],[t3_0,34]],
+      ExpAudit[[nil,0],[t1_0,10],[t3_1,32]],
+      ExpAudit[[nil,0],[t1_1,22],[t3_1,44]],
+      ExpAudit[[nil,2],[t2_0,12],[t3_1,34]],
+      ExpAudit[[nil,2],[t2_1,24],[t3_1,46]]
+    ], app._results(t3.batch))
+  end
+  
+  #
+  # other run tests
+  #
+  
+  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
-
+    t1.on_complete do |result|
+      if result._current < 4
+        t2.enq result
+      else
+        t3.enq result  
+      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
+    app.sequence(t2, t1)
+    
+    with_options :debug => true do
+      t1.enq(0)
+      t1.enq(2)
+      app.run
+    end
+    
+    assert_equal [0,2,1,3,2,4,3,5,4,5], runlist
 
-	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
+    assert_audits_equal([
+      ExpAudit[[nil,2],[t1,3],[t2,4],[t1,5],[t3,6]],
+      ExpAudit[[nil,0],[t1,1],[t2,2],[t1,3],[t2,4],[t1,5],[t3,6]]
+    ], app._results(t3.batch))
+  end
+  
+  #
+  # _results test
+  #
 
-	  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__results_returns_audited_results_for_listed_sources
+    t1 = Task.new {|task, input| input + 1 }
+    a1 = t1._execute(0)
+    
+    t2 = Task.new {|task, input| input + 1 } 
+    a2 = t2._execute(1)
+    
+    app.aggregator.store a1
+    app.aggregator.store a2
+    assert_equal [a1], app._results(t1)
+    assert_equal [a2, a1], app._results(t2, t1)
+    assert_equal [a1, a1], app._results(t1, t1)
+  end
+  
+  #
+  # results test
+  #
+  
+  def test_results_documentation
+    t1 = Task.new  {|task, input| input += 1 }
+    t2 = Task.new  {|task, input| input += 10 }
+    t3 = t2.initialize_batch_obj
+    
+    t1.enq(0)
+    t2.enq(1)
+    
+    app.run
+    assert_equal [1, 11, 11], app.results(t1, t2.batch)
+    assert_equal  [11, 1], app.results(t2, t1)
+  end
+  
+  def test_results_returns_current_values_of__results
+    t1 = Task.new {|task, input| input + 1 }
+    a1 = t1._execute(0)
+    
+    t2 = Task.new {|task, input| input + 1 } 
+    a2 = t2._execute(1)
+    
+    app.aggregator.store a1
+    app.aggregator.store a2
+    assert_equal [1], app.results(t1)
+    assert_equal [2, 1], app.results(t2, t1)
+    assert_equal [1, 1], app.results(t1, t1)
+  end
+  
+  def test_results_for_various_objects
+    t1 = Task.new {|task, input| input}
 
+    t1.enq({:key => 'value'})
+    t1.enq([1,2,3])
+    t1.enq(2)
+    t1.enq("str")
+    
+    app.run
+    assert_equal [{:key => 'value'}, [1,2,3], 2, "str"], app.results(t1)
+  end
+  
+  #
+  # synchronization tests
+  #
+  
+  def test_task_may_be_queued_from_task_while_task_is_running
+    count = 0
+    counter = Task.new do |task|
+      count += 1
+      counter.enq if count < 3
+    end
+  
+    with_options :debug => true do
+      counter.enq
+      app.run
+    end
+    
+    assert_equal 3, count
+  end
+  
+  def test_task_can_queue_from_within_threaded_and_unthreaded_tasks
+    threaded_count = 0
+    threaded = Task.new do |task|
+      runlist << "t"
+      threaded_count += 1
+      threaded.enq if threaded_count < 3
+    end
+  
+    not_threaded_count = 0
+    not_threaded = Task.new do |task|
+      runlist << "n"
+      not_threaded_count += 1
+      not_threaded.enq if not_threaded_count < 3
+    end
+  
+    threaded.multithread = true
+    threaded.enq
+    not_threaded.enq
+    
+    with_options :debug => true do
+      app.run
+    end
+    
+    assert_equal [
+      "t", "n", 
+      "t", "n", 
+      "t", "n"], runlist
+    assert_equal 3, threaded_count
+    assert_equal 3, not_threaded_count
+  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)
-
+      t2.enq input
+      app.run
+  
       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
-	
+  
+    with_options :debug => true do
+      t1.enq 0
+      app.run
+    end
+    
+    assert_equal [0,0], runlist
+    assert_audit_equal(ExpAudit[[nil,0],[t1,1]], app._results(t1).first)
+    assert_audit_equal(ExpAudit[[nil,0],[t2,1]], app._results(t2).first)
+  end
+  
+  def test_run_is_allowed_within_threaded_task
+    t2 = Task.new(&add_one)
+    t1 = Task.new do |task, input|
+      runlist << input
+      t2.enq input
+      app.run
+  
+      input += 1
+    end
+  
+    t1.multithread = true
+    t2.multithread = true
+    with_options :debug => true do
+      t1.enq 0
+      app.run
+    end
+    
+    assert_equal [0,0], runlist
+    assert_audit_equal(ExpAudit[[nil,0],[t1,1]], app._results(t1).first)
+    assert_audit_equal(ExpAudit[[nil,0],[t2,1]], app._results(t2).first)
+  end
+  
   #
   # error tests
   #
@@ -1455,36 +1663,39 @@ class AppTest < Test::Unit::TestCase
   end
   
   def test_unhandled_exception_on_main_thread_is_logged_by_default
-    t = Task.new {|t,i| raise "error"}
+    task = Task.new {|t| raise "error"}
      
     string = set_stringio_logger
-    app.run(t, nil)
+    task.enq
+    app.run
     
     assert string =~ /RuntimeError error/
   end
   
   def test_unhandled_exception_raises_run_error_on_main_thread_when_debug
-    t = Task.new {|t,i| raise "error"}
+    task = Task.new {|t| raise "error"}
      
     with_options :debug => true do
       begin
-        app.run(t, nil)
+        task.enq
+        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?
+        assert_equal 1 , $!.errors.length
+        assert $!.errors[0].kind_of?(RuntimeError)
+        assert_equal "error", $!.errors[0].message
       end
-  	end
+    end
   end
   
   def test_unhandled_exception_on_thread_is_logged_by_default
-    t = Task.new {|t,i| raise "error"}
-    t.multithread = true
+    task = Task.new {|t| raise "error"}
+    task.multithread = true
     
     string = set_stringio_logger
-    app.run(t, nil)
+    task.enq
+    app.run
     
     assert string =~ /RuntimeError error/
   end
@@ -1492,103 +1703,115 @@ class AppTest < Test::Unit::TestCase
   # Ruby inconsistent test
   #   <"error"> expected but was
   #   <"Tap::App::TerminateError">.
+  # RESOLVED? -- 2008/01/29
+  #
   def test_unhandled_exception_raises_run_error_on_thread_when_debug
-    t = Task.new {|t,i| raise "error"}
-    t.multithread = true
+    task = Task.new {|t| raise "error"}
+    task.multithread = true
     
     with_options :debug => true do
       begin
-        app.run(t, nil)
+        task.enq
+        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?
+        assert_equal 1 , $!.errors.length
+        assert $!.errors[0].kind_of?(RuntimeError)
+        assert_equal "error", $!.errors[0].message
       end
-  	end
+    end
   end
   
-  # TODO -- REWORD
-
   # Ruby inconsistent test
   #  <"error"> expected but was
   #  <"Tap::App::TerminateError">.
+  # RESOLVED? -- 2008/01/29
+  #
   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|
+        Task.new do |t|
           # count to make sure the tasks actually executed
           count += 1  
           
           terminated_count += 1
-          sleep 1
+          sleep 0.8
           t.check_terminate
           
           # this should not happen
           terminated_count -= 1
         end
       end
-      terr = Task.new {|t,i| raise "error"}
+      terr = Task.new {|t| raise "error"}
       
       tasks << terr
       tasks.each do |task|
         task.multithread = true
-        task.enq nil   
+        task.enq   
       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?
+          assert_equal 1 , $!.errors.length
+          assert $!.errors[0].kind_of?(RuntimeError)
+          assert_equal "error", $!.errors[0].message
         end
-    	end
-
+      end
+  
       assert_equal 2, count
       assert_equal 2, terminated_count
     end
   end
-
+  
   # Ruby inconsistent test
   #  <"error"> expected but was
   #  <"Tap::App::TerminateError">.
   #
   # <"term error 0"> expected but was
   # <"term error 1">.
+  # RESOLVED? -- 2008/01/29
   #
   # JRuby inconsistent test 
+  # RESOLVED? -- 2008/01/30
+  #
   def test_exceptions_from_handling_termination_error_are_collected
     extended_test do
+      lock = Monitor.new
       count = 0
       count_in_threaded_error_handling = 0
     
       tasks = Array.new(2) do
-        Task.new do |t,i|
-          n = count
-          begin
+        Task.new do |t|
+          n = nil
+          lock.synchronize do
+            n = count 
             count += 1
-            sleep 1
+          end
+          
+          sleep 0.8
+          
+          begin
             t.check_terminate
           rescue
-            count_in_threaded_error_handling += 1
+            lock.synchronize { count_in_threaded_error_handling += 1 }
             raise "term error #{n}"
           end
         end
       end
-      terr = Task.new {|t,i| raise "error"}
+      terr = Task.new {|t| raise "error"}
     
       tasks << terr
       tasks.each do |task|
         task.multithread = true
-        task.enq nil   
+        task.enq   
       end
     
       with_options :debug => true do
@@ -1597,20 +1820,30 @@ class AppTest < Test::Unit::TestCase
           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
+          assert_equal 3, $!.errors.length
+          $!.errors.each {|error| assert error.kind_of?(RuntimeError) }
+          messages = $!.errors.collect {|error| error.message}.sort
+          assert_equal ["error", "term error 0", "term error 1"], messages
         end
-    
+  
         assert_equal 2, count
         assert_equal 2, count_in_threaded_error_handling
       end
     end
   end
+  
+  #
+  # benchmarks
+  #
+  
+  def test_run_speed
+    t = Tap::Task.new 
+    benchmark_test(20) do |x|
+      n = 10000
+          
+      x.report("10k enq ") { n.times { t.enq(1) } }
+      x.report("10k run ") { n.times {}; app.run }
+      x.report("10k _execute ") { n.times { t._execute(1) } }
+    end
+  end
 end