tap 0.8.0 → 0.9.0

data/test/script_test.rb

@@ -1,194 +1,58 @@
 require  File.join(File.dirname(__FILE__), 'tap_test_helper')
 require 'tap/script'
 
-class ScriptConfigTest < Test::Unit::TestCase
-  include Tap
-  
-  acts_as_tap_test
-  
-  #
-  # class default tests
-  #
-  
-  def test_defaults
-    assert_equal({
-      :gems => [], 
-      :load_once_paths => [], 
-      :load_paths => ["lib"],
-      :script_paths => ["script"]},
-    ScriptConfig.defaults)
-  end
-  
-  #
-  # class spec_filepath test
-  #
-  
-  def test_spec_filepath
-    assert_equal "tapspec.yml", ScriptConfig.spec_filepath
-    assert_equal "path/to/dir/tapspec.yml", ScriptConfig.spec_filepath("path/to/dir")
-  end
-  
-  #
-  # default script config
-  #
-  
-  def test_default_script_config
-    config = ScriptConfig.new
-    assert config.kind_of?(OpenStruct)
-    assert_equal({
-      :gems => [],
-      :gemspecs => [], 
-      :load_once_paths => [], 
-      :load_paths => [app["lib"]],
-      :script_paths => [app["script"]]},
-    config.marshal_dump)
-  end
-  
-  def test_script_config_with_inputs
-    config = ScriptConfig.new :key => 'value', :load_paths => ['lib', 'test']
-
-    assert_equal({
-      :gems => [],
-      :gemspecs => [], 
-      :load_once_paths => [], 
-      :load_paths => [app["lib"], app['test']],
-      :script_paths => [app["script"]],
-      :key => 'value'},
-    config.marshal_dump)
-  end
-  
-  def test_single_arguments_are_allowed
-    config = ScriptConfig.new(
-      :load_paths => "alt",
-      :load_once_paths => "once")
-
-    assert_equal({
-      :gems => [],
-      :gemspecs => [], 
-      :load_once_paths => [app["once"]], 
-      :load_paths => [app["alt"]],
-      :script_paths => [app["script"]]},
-    config.marshal_dump)
-  end
-  
-  def test_gemspecs_and_paths_are_collected_for_the_specified_gem
-    config = ScriptConfig.new :gems => 'activesupport'
-    spec = Gem.loaded_specs["activesupport"]
-    
-    assert_equal 'activesupport', config.gems
-    assert_equal [spec], config.gemspecs
-    assert_equal [app['lib'], File.join(spec.full_gem_path, 'lib')], config.load_paths
-    assert_equal [app['script'], File.join(spec.full_gem_path, 'script')], config.script_paths
-  end
-  
-  #
-  # TODO -- find a way to test the gem loading behavior,  
-  # especially when the tapspec contains nested gems
-  # and when the tapspec contains unsafe filepaths
-  #
+class ScriptTest < Test::Unit::TestCase
+  include Tap::Script
   
   #
-  # TODO -- test scripts
+  # split_argv test
   #
-end
-
-class ScriptTest < Test::Unit::TestCase
-
-  acts_as_tap_test
   
-  def setup
-    super  
-    @load_path_hold = $LOAD_PATH.dup
-    Dependencies.load_paths.clear
-    Dependencies.load_once_paths.clear
+  def test_split_argv
+    argv = ["a", "-b", "--c", "--", "d", "-e", "--f"]
+    assert_equal([
+      [["a", "-b", "--c"], ["d", "-e", "--f"]]
+    ], split_argv(argv))
     
-    script.reset
-  end
-
-  def teardown
-    super
-    $LOAD_PATH.clear
-    $LOAD_PATH.concat @load_path_hold
-    Dependencies.load_paths.clear
-    Dependencies.load_once_paths.clear
+    argv.unshift("--")
+    argv.push("--")
+    assert_equal([
+      [["a", "-b", "--c"], ["d", "-e", "--f"]]
+    ], split_argv(argv))
+    
+    argv.concat ["--++", "x", "-y", "--z"]
+    assert_equal([
+      [["a", "-b", "--c"], ["d", "-e", "--f"]], 
+      [["x", "-y", "--z"]]
+    ], split_argv(argv))
+    
+    argv.concat ["--+", "m", "-n", "--o"]
+    assert_equal([
+      [["a", "-b", "--c"], ["d", "-e", "--f"]], 
+      [["m", "-n", "--o"]], 
+      [["x", "-y", "--z"]]
+    ], split_argv(argv))
   end
   
-  def script
-    Tap::Script.instance
-  end
-  
-  def tap_lib_dir
-    File.expand_path(File.dirname(__FILE__) + "/../lib")
-  end
-
   #
-  # configure_app tests
+  # parse_yaml tests
   #
   
-  def test_configure_returns_an_appropriate_script_config
-    config = script.configure_app
-
-    assert_equal [], config.gemspecs
-    assert_equal [], config.load_once_paths
-    assert_equal [tap_lib_dir, app['lib']], config.load_paths
-    assert_equal [app['script']], config.script_paths
-    
-    config = script.configure_app :load_paths => ['alt'], :key => 'value'
-
-    assert_equal [], config.gemspecs
-    assert_equal [], config.load_once_paths
-    assert_equal [tap_lib_dir, app['alt']], config.load_paths
-    assert_equal [app['script']], config.script_paths
-    assert_equal 'value', config.key
+  def test_parse_yaml_documentation
+    str = {'key' => 'value'}.to_yaml
+    assert_equal "--- \nkey: value\n", str
+    assert_equal({'key' => 'value'}, parse_yaml(str))
+    assert_equal "str", parse_yaml("str")
   end
   
-  def test_configure_app_sets_default_load_and_script_paths
-    assert !$LOAD_PATH.include?( app['lib'] )
-    assert_equal [], Dependencies.load_paths
-    assert_equal [], Dependencies.load_once_paths
-    
-    script.configure_app
-
-    assert $LOAD_PATH.include?( app['lib'] )
-    
-    assert_equal [tap_lib_dir, app['lib']], Dependencies.load_paths
-    assert_equal [], Dependencies.load_once_paths
-  end
-
-  def test_configure_app_resolves_aliases_and_sets_paths
-    app['lib'] = "alt_lib"
-    app['script'] = "alt_script"
-    app['load_once'] = "load/once/lib"
-    
-    assert !$LOAD_PATH.include?( app['lib'] )
-    assert_equal [], Dependencies.load_paths
-    assert_equal [], Dependencies.load_once_paths
-    
-    script.configure_app(
-      :load_paths => ["lib", "load_once"],
-      :load_once_paths => ["load_once"],
-      :script_paths => ['script'])
-
-    assert $LOAD_PATH.include?( app['lib'] )
-    assert $LOAD_PATH.include?( app['load_once'] )
-    
-    assert_equal [tap_lib_dir, app['lib'], app['load_once']], Dependencies.load_paths
-    assert_equal [app['load_once']], Dependencies.load_once_paths
+  def test_parse_yaml_loads_arg_if_arg_matches_yaml_document_string
+    string = "---\nkey: value"
+    assert_equal({"key" => "value"}, parse_yaml(string))
   end
   
-  def test_configure_app_raises_error_if_load_once_path_is_not_a_load_path
-    assert_raise(RuntimeError) do
-      script.configure_app(
-        :load_paths => [],
-        :load_once_paths => ["lib"])
-    end
+  def test_parse_yaml_returns_arg_unless_matches_yaml_document_string
+    string = "key: value"
+    assert_equal("key: value", parse_yaml(string))
   end
   
-  #
-  # split_to_length test
-  #
-  
-  # def test_split_to_length
-  #   assert_equal ["a a a a", "aaa aa ","a      "], Tap::Script.split_to_length("a a a a aaa aa \na", 7)
-  # end
 end

data/test/support/aggregator_test.rb

@@ -0,0 +1,99 @@
+require  File.join(File.dirname(__FILE__), '../tap_test_helper')
+require 'tap/support/aggregator'
+require 'tap/support/audit'
+
+class AggregatorTest < Test::Unit::TestCase
+  include Tap::Support
+  
+  attr_accessor :aggregator
+ 
+  def setup
+    @aggregator = Aggregator.new
+  end
+  
+  #
+  # store test
+  #
+  
+  def test_store_appends_audit_to_array_keyed_by_current_source
+    a = Audit.new
+    a._record(:a, 1)
+    assert_equal :a, a._current_source
+    
+    aggregator.store(a)
+    assert_equal({:a => [a]}, aggregator.to_hash)
+    
+    aggregator.store(a)
+    assert_equal({:a => [a, a]}, aggregator.to_hash)
+    
+    a._record(:b, 2)
+    assert_equal :b, a._current_source
+    
+    aggregator.store(a)
+    assert_equal({:a => [a, a], :b => [a]}, aggregator.to_hash)
+  end
+  
+  #
+  # clear test
+  #
+  
+  def test_clear
+    a = Audit.new
+    a._record(:a, 1)
+    
+    aggregator.store(a)
+    aggregator.store(a)
+    assert_equal({:a => [a, a]}, aggregator.to_hash)
+    
+    aggregator.clear
+    assert_equal({}, aggregator.to_hash)
+  end
+  
+  #
+  # retrieve test
+  #
+  
+  def test_retrieve_returns_array_for_source
+    a = Audit.new
+    a._record(:a, 1)
+    
+    aggregator.store(a)
+    aggregator.store(a)
+    assert_equal({:a => [a, a]}, aggregator.to_hash)
+    
+    assert_equal [a,a], aggregator.retrieve(:a)
+  end
+  
+  def test_retrieve_returns_nil_for_unknown_source
+    assert_nil aggregator.retrieve(:unknown)
+  end
+  
+  #
+  # retrieve_all test
+  #
+  
+  def test_retrieve_all_returns_concatenated_arrays_for_sources
+    a = Audit.new
+    a._record(:a, 1)
+    
+    aggregator.store(a)
+    aggregator.store(a)
+    
+    b = Audit.new
+    b._record(:b, 1)
+    aggregator.store(b)
+    
+    assert_equal({:a => [a, a], :b => [b]}, aggregator.to_hash)
+    
+    assert_equal [a,a], aggregator.retrieve_all(:a)
+    assert_equal [b], aggregator.retrieve_all(:b)
+    assert_equal [a,a,b], aggregator.retrieve_all(:a, :b)
+    assert_equal [b,a,a], aggregator.retrieve_all(:b, :a)
+    
+    assert_equal [a,a,b], aggregator.retrieve_all(:a, :unknown, :b)
+  end
+  
+  def test_retrieve_all_returns_empty_array_for_all_unknown_sources
+    assert_equal [], aggregator.retrieve_all(:a, :unknown, :b)
+  end
+end

data/test/support/audit_test.rb

@@ -2,311 +2,275 @@ require  File.dirname(__FILE__) + '/../tap_test_helper'
 require 'tap/support/audit'
 
 class AuditTest < Test::Unit::TestCase
-	include Tap::Support
-	
-	attr_reader :audit, :a, :b
-	
-	def setup
-		@audit = Audit.new('original')
-		@a = setup_audit(:a, :b, :c)
-		@b = setup_audit(:x, :y, :z)
-	end
-	
-	# 
-	# class methods tests 
-	#
-	
-	def test_register_creates_an_audit_for_each_input_as_needed
-	  registered = Audit.register(1, a, 2)
-	  
-	  registered.each {|r| assert_equal Audit, r.class}
-	  assert_equal a.object_id, registered[1].object_id
-	  assert_equal [1, 'c', 2], registered.collect {|r| r._current}
-	end
-	
-	def test_merge_with_multiple_inputs_merges_inputs
-	  m = Audit.merge(1, a, 2)
-	  
-	  assert_equal [[1, 'c', 2]], m._values 
-	  assert_equal [[nil, a, nil]], m._sources 
-	end
-	
-	def test_merge_with_a_single_non_audit_input_returns_new_audit
-	  m = Audit.merge(1)
-	  
-	  assert_equal [1], m._values 
-	  assert_equal [nil], m._sources 
-	end
-	
-	def test_merge_with_a_single_audit_input_returns_fork
-	  m = Audit.merge(a)
-	  
-	  assert_not_equal a.object_id, m.object_id
-	  assert_equal a._values, m._values 
-	  assert_equal a._sources, m._sources
-	end
-	
-	def test_merge_with_no_inputs_returns_audit_initialized_to_nil
-	  m = Audit.merge
-	  
-	  assert_equal [nil], m._values 
-	  assert_equal [nil], m._sources
-	end
-	
-	def test_merge_documentation
-	  a = Audit.new(1)
-    b = Audit.merge(a, 2)
-    assert_equal [[1,2]], b._values           
-    assert_equal [[a, nil]], b._sources           
-	end
-	
-	#
-	# methods to setup audits for testing, and tests of the setup
-	#
-	
-	def setup_audit(*sources)
-		audit = Audit.new
-		sources.each do |source|
-			value = case source
-			when Array
-			  source.collect {|s| s.to_s }
-			else
-			  source.to_s
-			end
-			
-			audit._record(source, value)
-		end
-		audit
-	end
-
-	def test_setup
-		assert_equal [nil], audit._sources
-		assert_equal ['original'], audit._values
-		assert_equal 'original', audit._original
-		assert_equal 'original', audit._current
-		
-		assert_equal [nil, :a, :b, :c], a._sources
-		assert_equal [nil, 'a', 'b', 'c'], a._values
-		assert_equal 'c', a._current
-		assert_equal nil, a._original
-		
-		assert_equal [nil, :x, :y, :z], b._sources
-		assert_equal [nil, 'x', 'y', 'z'], b._values	
-		assert_equal 'z', b._current
-		assert_equal nil, b._original
-		
-		c = setup_audit([a, b, :c])
-		assert_equal [nil, [a, b, :c]], c._sources
-		assert_equal [nil, [a.to_s, b.to_s, 'c']], c._values
-	end
-
-	#
-	# record tests
-	#
-	
-	def test_record
-		audit._record(:a, 'next')
-		audit._record(:b, 'final')
-		
-		assert_equal [nil, :a, :b], audit._sources
-		assert_equal ['original', 'next', 'final'], audit._values
-	end
-	
-	def test_record_with_arrays_and_audits
-		audit._record(:a, a)
-		audit._record(:array, [a, b, 'str'])
-		
-		assert_equal [nil, :a, :array], audit._sources
-		assert_equal ['original', a, [a, b, 'str']], audit._values
-	end
-
-	def test_record_returns_self
-		assert audit._eql( audit._record(:a, 'next') )
-	end
-
-	#
-	# original tests
-	#
-	
-	def test_original_is_first_recorded_value
-	  a = Audit.new('a', :a)
-	  assert_equal 'a', a._original
-	  
-		audit._record(:b, 'next')
-		assert_equal 'a', a._original
-	end
-	
-	def test_original_source_is_original_recorded_source
-	  a = Audit.new('a', :a)
-	  assert_equal :a, a._original_source
-	  
-		audit._record(:b, 'next')
-		assert_equal :a, a._original_source
-	end  
-
-	#
-	# current tests
-	#
-	
-	def test_current_is_last_recorded_value
-		audit._record(:a, 'next')
-		assert_equal 'next', audit._current
-		
-		audit._record(:a, 'final')
-		assert_equal 'final', audit._current
-	end
-	
-	def test_current_source_is_last_recorded_source
-		audit._record(:a, 'next')
-		assert_equal :a, audit._current_source
-		
-		audit._record(:b, 'final')
-		assert_equal :b, audit._current_source
-	end
-	
-	#
-	# last tests
-	#
-	
-	def test_last_is_value_of_last_source_equalling_input
-		assert_equal 'a', a._last(:a)
-		
-		a._record(:a, 'next')
-		assert_equal 'next', a._last(:a)
-		
-		a._record(:b, 'does not affect last :a')
-		assert_equal 'next', a._last(:a)
-	end
-	
-	def test_index_last_is_index_of_last_source_equalling_input
-		assert_equal 1, a._index_last(:a)
-		
-		a._record(:a, 'next')
-		assert_equal 4, a._index_last(:a)
-		
-		a._record(:b, 'does not affect last :a')
-		assert_equal 4, a._index_last(:a)
-	end
-	
-	#
-	# input accessor tests
-	#
-	
-	def test_input_returns_value_at_index
-		assert_equal 'c', a._input(3)
-		assert_equal 'c', a._input(-1)
-	end
-	
-	def test_input_last_is_value_previous_to_matching_source
-		assert_equal nil, a._input_last(:a)
-		
-		a._record(:a, 'next')
-		assert_equal 'c', a._input_last(:a)
-		
-		a._record(:b, 'does not affect input last :a')
-		assert_equal 'c', a._input_last(:a)
-	end
-	
-	#
-	# output accessor tests 
-	#
-	
-	def test_output_is_value_of_next_index
-		assert_equal 'c', a._output(2)
-		assert_equal 'c', a._output(-2)
-		
-		assert_nil a._output(3)
-		assert_nil a._output(-1)
-	end
-	
-	def test_output_last_is_value_of_matching_source
-		assert_equal 'a', a._output_last(:a)
-		
-		a._record(:a, 'next')
-		assert_equal 'next', a._output_last(:a)
-		
-		a._record(:b, 'does not affect output last :a')
-		assert_equal 'next', a._output_last(:a)
-	end
-	
-	#
-	# source trail tests
-	#
-	
-	def test_source_trail_helper_method_is_hidden
-	  assert !a.respond_to?(:source_trail)
-	  assert_raise(NoMethodError) { a.source_trail }
-	end
-	
-	def test_source_trail_returns_all_sources
-		a = setup_audit(:a, :b, :c)
-
-		assert_equal [nil, :a, :b, :c], a._source_trail
-	end
-	
-	def test_source_trail_returns_source_trail_when_source_is_an_audit
-		c = setup_audit(:p, a, :q)
-		
-		assert_equal [nil, :p, a, :q], c._sources
-		assert_equal [nil, :p, [nil, :a, :b, :c], :q], c._source_trail
-	end
-	
-	def test_source_trail_resolves_each_member_in_an_arrays_of_sources
-		c = setup_audit(:p, [a, b, :q], [:r, :s], :t)
-
-		assert_equal [nil, :p, [[nil, :a, :b, :c], [nil, :x, :y, :z], :q],[:r, :s], :t], c._source_trail
-	end
-	
-	#
-	# value trail tests
-	#
-	
-	def test_value_trail_helper_method_is_hidden
-	  assert !a.respond_to?(:value_trail)
-	  assert_raise(NoMethodError) { a.value_trail }
-	end
-	
-	def test_value_trail_returns_all_values
-		a = setup_audit(:a, :b, :c)
-
-		assert_equal [nil, 'a', 'b', 'c'], a._value_trail
-	end
-	
-	def test_value_trail_returns_value_trail_when_source_is_an_audit
-		c = setup_audit(:p, a, :q)
-		
-		assert_equal [nil, :p, a, :q], c._sources
-		assert_equal [nil, 'p', [nil, 'a', 'b', 'c'], 'q'], c._value_trail
-	end
-	
-	def test_value_trail_resolves_each_member_in_an_arrays_of_sources
-		c = setup_audit(:p, [a, b, :q], [:r, :s], :t)
-
-		assert_equal [nil, 'p', [[nil, 'a', 'b', 'c'], [nil, 'x', 'y', 'z'], 'q'],['r', 's'], 't'], c._value_trail
-	end
-	
-	#		
-	# merge tests
-	#
-	
-	def test_merge_returns_new_audit_with_self_added_to_sources_and_value_as_array_of_current_values
-		c = a._merge(b, 'p')
-		c._record(:q, 'q')
-		c._record(:r, 'r')
-		
-		assert_equal [[a, b, nil], :q, :r], c._sources
-		assert_equal [['c', 'z', 'p'], 'q', 'r'], c._values
-		assert_equal [[[nil, :a, :b, :c], [nil, :x, :y, :z], nil], :q, :r], c._source_trail
-	end
-	
-	def test_merge_with_no_sources_provided_returns_fork
-	  c = a._merge
-	  
-	  assert_not_equal a.object_id, c.object_id
-	  assert_equal a._sources, c._sources
-	  assert_equal a._values, c._values
-	end
-	
+  include Tap::Support
+  
+  attr_reader :audit, :a, :b
+  
+  def setup
+    @audit = Audit.new('original')
+    @a = setup_audit(:a, :b, :c)
+    @b = setup_audit(:x, :y, :z)
+  end
+  
+  #
+  # methods to setup audits for testing, and tests of the setup
+  #
+  
+  def setup_audit(*sources)
+    audit = Audit.new
+    sources.each do |source|
+      value = case source
+      when Array
+        source.collect {|s| s.to_s }
+      else
+        source.to_s
+      end
+      
+      audit._record(source, value)
+    end
+    audit
+  end
+
+  def test_setup
+    assert_equal [nil], audit._sources
+    assert_equal ['original'], audit._values
+    assert_equal 'original', audit._original
+    assert_equal 'original', audit._current
+    
+    assert_equal [:a, :b, :c], a._sources
+    assert_equal ['a', 'b', 'c'], a._values
+    assert_equal 'c', a._current
+    assert_equal 'a', a._original
+    
+    assert_equal [:x, :y, :z], b._sources
+    assert_equal ['x', 'y', 'z'], b._values  
+    assert_equal 'z', b._current
+    assert_equal 'x', b._original
+    
+    c = setup_audit([a, b, :c])
+    assert_equal [[a, b, :c]], c._sources
+    assert_equal [[a.to_s, b.to_s, 'c']], c._values
+  end
+  
+  #
+  # documentation tests
+  #
+  
+  def test_documentation
+    # initialize a new audit
+    a = Audit.new(1, nil)
+  
+    # record some values
+    a._record(:A, 2)
+    a._record(:B, 3)
+
+    assert_equal [nil, :A, :B], a._source_trail 
+    assert_equal [1, 2, 3], a._value_trail
+    assert_equal 1, a._original
+    assert_equal nil, a._original_source
+    assert_equal 3, a._current
+    assert_equal :B, a._current_source
+
+    b = Audit.new(10, nil)
+    b._record(:C, 11)
+    b._record(:D, 12)  
+  
+    c = Audit.merge(a, b)
+    assert_equal [ [[nil, :A, :B], [nil, :C, :D]] ], c._source_trail
+    assert_equal [ [[1,2,3], [10, 11, 12]] ], c._value_trail   
+    assert_equal [3, 12], c._current
+  
+    c._record(:E, "a string value")
+    c._record(:F, {'a' => 'hash value'})
+    c._record(:G, ['an', 'array', 'value'])
+  
+    assert_equal [ [[nil, :A, :B], [nil, :C, :D]], :E, :F, :G], c._source_trail
+    assert_equal [ [[1,2,3], [10, 11, 12]], "a string value", {'a' => 'hash value'}, ['an', 'array', 'value']], c._value_trail
+  
+    a1 = a._fork
+    a._record(:X, -1)
+    a1._record(:Y, -2)
+
+    assert_equal [nil, :A, :B, :X], a._source_trail
+    assert_equal [nil, :A, :B, :Y], a1._source_trail
+    assert_equal [ [[nil, :A, :B], [nil, :C, :D]], :E, :F, :G], c._source_trail 
+
+    expected = %Q{o-[] 1
+o-[A] 2
+o-[B] 3
+| 
+| o-[] 10
+| o-[C] 11
+| o-[D] 12
+| | 
+`-`-o-[E] "a string value"
+    o-[F] {"a"=>"hash value"}
+    o-[G] ["an", "array", "value"]
+}
+
+    assert_equal expected, c._to_s
+  end
+
+  #   
+  # Audit merge tests
+  #
+
+  def test_merge_documentation
+    a = Audit.new
+    a._record(:a, 'a')
+
+    b = Audit.new
+    b._record(:b, 'b')
+
+    c = Audit.merge(a, b, 1)
+    c._record(:c, 'c')
+
+    assert_equal [['a','b', 1], 'c'], c._values
+    assert_equal [AuditMerge[a, b, Audit.new(1)], :c], c._sources
+  end
+
+  def test_merge
+    c = Audit.merge(a, b, 'p')
+    c._record(:q, 'q')
+    c._record(:r, 'r')
+  
+    assert_equal [AuditMerge[a, b, Audit.new('p')], :q, :r], c._sources
+    assert_equal [['c', 'z', 'p'], 'q', 'r'], c._values
+  
+    assert_equal [[[:a, :b, :c], [:x, :y, :z], [nil]], :q, :r], c._source_trail
+    assert_equal [[['a', 'b', 'c'], ['x', 'y', 'z'], ['p']], 'q', 'r'], c._value_trail
+  end
+
+  def test_merge_with_one_input_returns_fork
+    c = Audit.merge(a)
+    assert_equal c, a
+  end
+
+  def test_merge_with_no_inputs_returns_new_audit
+    a = Audit.merge
+    assert_equal Audit.new, a
+  end
+
+  #
+  # record tests
+  #
+  
+  def test_record
+    audit._record(:a, 'next')
+    audit._record(:b, 'final')
+    
+    assert_equal [nil, :a, :b], audit._sources
+    assert_equal ['original', 'next', 'final'], audit._values
+  end
+  
+  def test_record_with_arrays_and_audits
+    audit._record(:a, a)
+    audit._record(:array, [a, b, 'str'])
+    
+    assert_equal [nil, :a, :array], audit._sources
+    assert_equal ['original', a, [a, b, 'str']], audit._values
+  end
+
+  def test_record_returns_self
+    assert audit, audit._record(:a, 'next')
+  end
+
+  #
+  # original tests
+  #
+  
+  def test_original_is_first_recorded_value
+    a = Audit.new('a', :a)
+    assert_equal 'a', a._original
+    
+    audit._record(:b, 'next')
+    assert_equal 'a', a._original
+  end
+  
+  def test_original_source_is_original_recorded_source
+    a = Audit.new('a', :a)
+    assert_equal :a, a._original_source
+    
+    audit._record(:b, 'next')
+    assert_equal :a, a._original_source
+  end  
+
+  #
+  # current tests
+  #
+  
+  def test_current_is_last_recorded_value
+    audit._record(:a, 'next')
+    assert_equal 'next', audit._current
+    
+    audit._record(:a, 'final')
+    assert_equal 'final', audit._current
+  end
+  
+  def test_current_source_is_last_recorded_source
+    audit._record(:a, 'next')
+    assert_equal :a, audit._current_source
+    
+    audit._record(:b, 'final')
+    assert_equal :b, audit._current_source
+  end
+
+  #
+  # source trail tests
+  #
+  
+  def test_source_trail_helper_method_is_hidden
+    assert !a.respond_to?(:source_trail)
+    assert_raise(NoMethodError) { a.source_trail }
+  end
+  
+  def test_source_trail_returns_all_sources
+    a = setup_audit(:a, :b, :c)
+
+    assert_equal [:a, :b, :c], a._source_trail
+  end
+  
+  def test_source_trail_returns_source_trail_when_source_is_an_audit
+    c = setup_audit(:p, a, :q)
+    
+    assert_equal [:p, a, :q], c._sources
+    assert_equal [:p, [:a, :b, :c], :q], c._source_trail
+  end
+  
+  def test_source_trail_resolves_each_member_in_an_audit_merge_source
+    c = setup_audit(:p, AuditMerge[a, b, :q], [:r, :s], :t)
+
+    assert_equal [:p, [[:a, :b, :c], [:x, :y, :z], :q],[:r, :s], :t], c._source_trail
+  end
+  
+  #
+  # value trail tests
+  #
+  
+  def test_value_trail_helper_method_is_hidden
+    assert !a.respond_to?(:value_trail)
+    assert_raise(NoMethodError) { a.value_trail }
+  end
+  
+  def test_value_trail_returns_all_values
+    a = setup_audit(:a, :b, :c)
+
+    assert_equal ['a', 'b', 'c'], a._value_trail
+  end
+  
+  def test_value_trail_returns_value_trail_when_source_is_an_audit
+    c = setup_audit(:p, a, :q)
+    
+    assert_equal [:p, a, :q], c._sources
+    assert_equal ['p', ['a', 'b', 'c'], 'q'], c._value_trail
+  end
+  
+  def test_value_trail_resolves_each_member_in_an_audit_merge_source
+    c = setup_audit(:p, AuditMerge[a, b, :q], [:r, :s], :t)
+
+    assert_equal ['p', [['a', 'b', 'c'], ['x', 'y', 'z'], 'q'],['r', 's'], 't'], c._value_trail
+  end
+  
   #
   # test fork  
   #
@@ -328,125 +292,154 @@ class AuditTest < Test::Unit::TestCase
     a._record(:c, 'c')
     b._record(:d, 'd')
 
-    assert_equal([nil, :a, :b, :c], a._sources)
-    assert_equal([nil, :a, :b, :d], b._sources)
-  end
-  
-	#
-	# split tests
-	#
-	
-	def test_split_records_block_as_source_and_return_as_value
-		block = lambda { |current| current += 'ar' }
-		c = a._split(&block)
-		
-		assert_equal [a, block], c._sources
-		assert_equal [nil, 'car'], c._values
-		assert_equal [[nil, :a, :b, :c], block], c._source_trail
-	end
-	
-	def test_split_raises_error_if_no_block_given
-		assert_raise(LocalJumpError) { a._split }
-	end
-	
-	#
-	# comparator and method missing test
-	#
-	
-	def test_comparators_sent_to_current
-		a = Audit.new(1)
-		assert a < 2
-		assert a > 0
-		assert a == 1
-	end
-	
-	def test_regexp_match_sent_to_current
-		a = Audit.new("abcd")
-		assert a =~ /ab(\w)/
-		# note: this is not ideal behavior... should be
-		#assert_equal 'c', $1 
-		assert_nil $1
-		
-		assert !(a=~ /q/)
-	end
-	
-	def test_regexp_not_match_sent_to_current
-		a = Audit.new("abcd")
-		assert !(a !~ /ab(\w)/)
-		# note: this is not ideal behavior... should be
-		#assert_equal 'c', $1 
-		assert_nil $1
-		
-		assert a !~ /q/
-	end
-	
-	def test_missing_methods_sent_to_current
-		a = Audit.new("abcd")
-		assert "ABCD", a.upcase
-		
-		a = Audit.new(3)
-		assert a > 2
-		assert a <= 3
-	end
-	
-	#
-	# documentation tests
+    assert_equal([:a, :b, :c], a._sources)
+    assert_equal([:a, :b, :d], b._sources)
+  end
+  
+  #
+  # split tests
   #
   
-  def test_documentation
-    # reset the app, in case it is in an unexpected state
-    Tap::App.instance = nil  
-    
-    # part 1
-    audit = Audit.new(3)
-    audit._record(:a, 4)
-    audit._record(:b, 5)
-    audit._record(:c, 7)
-    assert_equal([nil, :a, :b, :c], audit._source_trail)
+  def test_split_forks_and_records_result_yielding_to_current
+    block = lambda { |current| current += 'ar' }
+    c = a._split(&block)
     
-    # part 2
-    audit = Audit.new(3)
-    audit._record(:a, 4)
-    fork_b = audit._fork
-    fork_c = audit._fork 
+    assert_equal [:a, :b, :c, AuditSplit.new(block)], c._sources
+    assert_equal ['a', 'b', 'c', 'car'], c._values
+  end
+  
+  def test_split_raises_error_if_no_block_given
+    assert_raise(LocalJumpError) { a._split }
+  end
+  
+  #
+  # expand tests
+  #
+  
+  def test_expand_forks_for_and_records_each_in_current
+    a = Audit.new([1,2,3])
+    e = a._expand
     
-    fork_b._record(:b, 5)
-    fork_c._record(:c, 6)
-    assert_equal([nil, :a, :b], fork_b._source_trail)
-    assert_equal([nil, :a, :c], fork_c._source_trail)
+    assert_equal 3, e.length
     
-    merged_audit = Audit.merge(fork_b, fork_c)
-    merged_audit._record(:d, 11)
-    assert_equal([[[nil,:a,:b], [nil,:a,:c]], :d], merged_audit._source_trail)
+    assert_equal [nil, AuditExpand.new(0)], e[0]._sources
+    assert_equal [[1,2,3], 1],  e[0]._values
     
-    # part 3
-    t = Tap::Task.new 
-    t.on_complete do |results|
-     results.each do |result|
-
-      assert_equal Audit, result.class          
-      assert_equal "str", result._current        
-      assert result == "str"        
-      assert_equal "STR", result.upcase           
+    assert_equal [nil, AuditExpand.new(1)], e[1]._sources
+    assert_equal [[1,2,3], 2],  e[1]._values
     
-      assert !result.kind_of?(String)
-      assert result =~ /s(\w+)/  
-      assert_nil $1                     
-      
-      end
-    end 
-    t.execute "str"
+    assert_equal [nil, AuditExpand.new(2)], e[2]._sources
+    assert_equal [[1,2,3], 3],  e[2]._values
+  end
+  
+  def test_expand_raises_error_if_current_does_not_respond_to_each
+    a = Audit.new(nil)
+    assert_raise(NoMethodError) { a._expand }
+  end
+  
+  #
+  # _to_s test
+  #
+
+  def new_audit(letter, n=0)
+    a = Tap::Support::Audit.new
+    1.upto(n) {|i| a._record(letter, "#{letter}#{i}")}
+    a
+  end
+
+  def test_to_s_for_sequence
+    a = Audit.new
+    assert_equal %Q{\n}, a._to_s
+
+    a = new_audit(:a, 3)
+    assert_equal %Q{
+o-[a] "a1"
+o-[a] "a2"
+o-[a] "a3"
+}[1..-1], a._to_s
+  end
+
+  def test_to_s_for_fork_is_same_as_forked
+    a = new_audit(:a)
+    assert_equal a._to_s, a._fork._to_s
+
+    a = new_audit(:a, 3)._fork
+    assert_equal a._to_s, a._fork._to_s
+  end
+
+  def test_to_s_for_merge_without_additional_records
+    a = new_audit(:a, 3)
+    b = new_audit(:b, 3)
+    c = Tap::Support::Audit.merge(a,b)
+
+    assert_equal %Q{
+o-[a] "a1"
+o-[a] "a2"
+o-[a] "a3"
+| 
+| o-[b] "b1"
+| o-[b] "b2"
+| o-[b] "b3"
+}[1..-1], c._to_s
+  end
+
+  def test_to_s_for_merge_with_additional_records
+    a = new_audit(:a, 3)
+    b = new_audit(:b, 3)
+    c = Tap::Support::Audit.merge(a,b)
+    1.upto(3) {|i| c._record(:c, "c#{i}")}
+   
+    assert_equal %Q{
+o-[a] "a1"
+o-[a] "a2"
+o-[a] "a3"
+| 
+| o-[b] "b1"
+| o-[b] "b2"
+| o-[b] "b3"
+| | 
+`-`-o-[c] "c1"
+    o-[c] "c2"
+    o-[c] "c3"
+}[1..-1], c._to_s
+  end
+  
+  def test_to_s_for_merge_with_multiple_input_audits
+    a = new_audit(:a, 1)
+    b = new_audit(:b, 1)
+    c = Tap::Support::Audit.merge(a,b)
+    1.upto(1) {|i| c._record(:c, "c#{i}")}
     
-    # part 4
-    t = Tap::Task.new do |task, input|
-      assert_equal Fixnum, input.class
-      input += 1
-    end
+    d = new_audit(:d, 1)
+    e = new_audit(:e, 1)
+    f = Tap::Support::Audit.merge(d, e, 'x1', 'y1', 'z1')
+    1.upto(1) {|i| f._record(:f, "f#{i}")}
     
-    results = t.execute(3)   
-    assert_equal Array, results.class
-    assert_equal 1, results.length  
-    assert_equal Audit, results.first.class        
-    assert_equal 4, results.first._current    
+    g = Tap::Support::Audit.merge(c, f)
+    1.upto(1) {|i| g._record(:g, "g#{i}")}
+
+    assert_equal %Q{
+o-[a] "a1"
+| 
+| o-[b] "b1"
+| | 
+`-`-o-[c] "c1"
+    | 
+    | o-[d] "d1"
+    | | 
+    | | o-[e] "e1"
+    | | | 
+    | | | o-[] "x1"
+    | | | | 
+    | | | | o-[] "y1"
+    | | | | | 
+    | | | | | o-[] "z1"
+    | | | | | | 
+    | `-`-`-`-`-o-[f] "f1"
+    |           | 
+    `-----------`-o-[g] "g1"
+}[1..-1], g._to_s
   end
+  
+  
 end