tap 0.7.9

data/test/support/audit_test.rb

@@ -0,0 +1,449 @@
+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
+	
+  #
+  # test fork  
+  #
+  
+  def test_fork_returns_audit_with_duplicates_of_sources_and_values
+    a = setup_audit(:a, :b, :c)
+    b = a._fork
+    
+    assert_equal b._sources, a._sources
+    assert_not_equal b._sources.object_id, a._sources.object_id
+    assert_equal b._values, a._values
+    assert_not_equal b._values.object_id, a._values.object_id
+  end
+  
+  def test_forks_can_be_developed_independently
+    a = setup_audit(:a, :b)
+    b = a._fork
+    
+    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
+  #
+  
+  def test_documentation
+    # 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)
+    
+    # part 2
+    audit = Audit.new(3)
+    audit._record(:a, 4)
+    fork_b = audit._fork
+    fork_c = audit._fork 
+    
+    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)
+    
+    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)
+    
+    # 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 !result.kind_of?(String)
+      assert result =~ /s(\w+)/  
+      assert_nil $1                     
+      
+      end
+    end 
+    t.execute "str"
+    
+    # part 4
+    t = Tap::Task.new do |task, input|
+        assert_equal Fixnum, input.class
+        input += 1
+    end
+    
+    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    
+  end
+end

data/test/support/batch_queue_test.rb

@@ -0,0 +1,320 @@
+require  File.join(File.dirname(__FILE__), '../tap_test_helper')
+require 'tap/support/batch_queue'
+
+class BatchQueueTest < Test::Unit::TestCase
+  
+  # creates readers to facilitate testing
+  module BatchQueueAccessors
+    attr_reader :tasks, :inputs
+  end
+
+  attr_accessor :t, :not_executable, :queue
+ 
+  def setup
+    @t = Tap::Task.new
+    @not_executable = Tap::Task.new
+    @not_executable.condition {|task, inputs| false}
+    
+    @queue = Tap::Support::BatchQueue.new
+    @queue.extend BatchQueueAccessors
+  end
+  
+  def test_not_executable_is_not_executable_with_and_without_inputs
+    assert !not_executable.executable?([])
+    assert !not_executable.executable?([:a,:b,:c])
+  end
+  
+  def test_documentation
+    t1 = Tap::Task.new
+    t2 = Tap::Task.new
+    
+    q = Tap::Support::BatchQueue.new
+    q.enq t1, 1
+    q.enq t2, :a,:b,:c
+    q.enq t1, 2,3
+      
+    assert_equal [t1, [1,2,3]], q.deq
+    assert_equal [t2, [:a,:b,:c]], q.deq   
+    assert_nil q.deq    
+  end
+  
+  #
+  # initialization tests
+  #
+  
+  def test_queue_is_empty_and_inputs_and_tasks_cannot_be_accessed
+    q = Tap::Support::BatchQueue.new
+    assert q.empty?
+    assert_raise(NoMethodError) { q.inputs }
+    assert_raise(NoMethodError) { q.tasks }
+  end
+  
+  #
+  # size, length, clear, empty? tests
+  #
+  
+  def test_size_and_length_return_number_of_tasks
+    assert_equal 0, queue.size
+    assert_equal 0, queue.length
+    
+    queue.inputs[t] = [1,2,3]
+    
+    assert_equal 0, queue.size
+    assert_equal 0, queue.length
+    
+    queue.tasks << t
+    
+    assert_equal 1, queue.size
+    assert_equal 1, queue.length
+  end
+  
+  def test_empty_is_true_if_tasks_is_empty
+    assert queue.empty?
+    queue.inputs[t] = [1,2,3]
+    assert queue.empty?
+    queue.tasks << t
+    assert !queue.empty?
+  end
+  
+  def test_clear_resets_tasks_and_inputs
+    assert_equal({}, queue.inputs)
+    assert_equal [], queue.tasks
+    
+    queue.inputs[t] = [1,2,3]
+    queue.tasks << t
+    queue.clear
+    
+    assert_equal({}, queue.inputs)
+    assert_equal [], queue.tasks
+  end
+  
+  #
+  # queue test
+  #
+  
+  def test_enq_pushes_task_onto_tasks
+    t1 = Tap::Task.new
+    t2 = Tap::Task.new
+    assert_equal [], queue.tasks
+    
+    queue.enq(t1)
+    assert_equal [t1], queue.tasks
+    
+    queue.enq(t2)
+    assert_equal [t1, t2], queue.tasks
+  end
+  
+  def test_enq_concats_inputs_to_inputs
+    assert_equal nil, queue.inputs[t]
+    
+    queue.enq(t,1)
+    assert_equal [1], queue.inputs[t]
+    
+    queue.enq(t,2,3)
+    assert_equal [1,2,3], queue.inputs[t]
+  end
+  
+	def test_enq_does_not_push_task_onto_tasks_if_it_is_already_in_the_queue
+    t1 = Tap::Task.new
+    t2 = Tap::Task.new
+    queue.tasks << t1
+    queue.tasks << t2
+    assert_equal [t1,t2], queue.tasks
+    
+    queue.enq(t1)
+    assert_equal [t1,t2], queue.tasks
+  end
+  
+  def test_enq_queues_batch_if_task_is_batched
+    t.batch << t.dup
+    assert_equal [], queue.tasks
+    
+    queue.enq(t)
+    assert_equal t.batch, queue.tasks
+  end
+  
+  def test_enq_forks_inputs_if_necessary_for_batch
+    t.batch << t.dup
+    
+    a = Tap::Support::Audit.new(2)
+    queue.enq(t, 1, a)
+    
+    audits = []
+    t.batch.each do |task|
+      assert_equal [1, a], queue.inputs[task]
+      audits << queue.inputs[task].last
+    end
+    
+    # if the object ids of these audits are not equal, but they
+    # evaluate to equal, we can safely assume they're forked.
+    assert_equal 2, audits.length
+    assert_equal audits.first, audits.last
+    assert_not_equal audits.first.object_id, audits.last.object_id
+  end
+  
+  #
+  # priority_enq test
+  #
+  
+  def test_priority_enq_shifts_task_onto_tasks
+    t1 = Tap::Task.new
+    t2 = Tap::Task.new
+    assert_equal [], queue.tasks
+    
+    queue.priority_enq(t1)
+    assert_equal [t1], queue.tasks
+    
+    queue.priority_enq(t2)
+    assert_equal [t2, t1], queue.tasks
+  end
+  
+  #
+  # prioritize test
+  #
+  
+  def test_prioritize_moves_task_to_the_front_of_the_queue
+    t1 = Tap::Task.new
+    t2 = Tap::Task.new
+    queue.tasks << t1
+    queue.tasks << t2
+    assert_equal [t1,t2], queue.tasks
+    
+    queue.prioritize(t2)
+    assert_equal [t2,t1], queue.tasks
+  end
+  
+  def test_prioritize_does_not_insert_the_task_if_the_task_is_not_in_the_queue
+    assert_equal [], queue.tasks
+    
+    queue.prioritize(t)
+    assert_equal [], queue.tasks
+  end
+  
+  def test_prioritize_prioritizes_each_task_in_a_batch_in_order
+    t1 = Tap::Task.new
+    t2 = Tap::Task.new
+    t2.batch << t2.dup
+    
+    queue.tasks << t1
+    queue.tasks.concat t2.batch
+    
+    assert_equal [t1] + t2.batch, queue.tasks
+    
+    queue.prioritize(t2)
+    assert_equal t2.batch + [t1], queue.tasks
+  end
+  
+  #
+  # marginalize test
+  #
+  
+  def test_marginalize_moves_task_to_the_front_of_the_queue
+    t1 = Tap::Task.new
+    t2 = Tap::Task.new
+    queue.tasks << t1
+    queue.tasks << t2
+    assert_equal [t1,t2], queue.tasks
+    
+    queue.marginalize(t1)
+    assert_equal [t2,t1], queue.tasks
+  end
+  
+  def test_marginalizeoes_not_insert_the_task_if_the_task_is_not_in_the_queue
+    assert_equal [], queue.tasks
+    
+    queue.marginalize(t)
+    assert_equal [], queue.tasks
+  end
+  
+  def test_marginalize_marginalizes_each_task_in_a_batch_in_order
+    t1 = Tap::Task.new
+    t2 = Tap::Task.new
+    t2.batch << t2.dup
+    
+    queue.tasks.concat t2.batch
+    queue.tasks << t1
+    
+    assert_equal t2.batch + [t1], queue.tasks
+    queue.marginalize(t2)
+    assert_equal [t1] + t2.batch, queue.tasks
+  end
+  
+  #
+  # executable? tests
+  #
+  
+  def test_executable_true_if_task_is_executable_with_current_inputs
+    t.condition {|task, inputs| inputs && inputs.length > 1 }
+    
+    assert !queue.executable?(t)
+    queue.enq t,1
+    assert !queue.executable?(t)
+    queue.enq t,2
+    assert queue.executable?(t)
+  end
+  
+  #
+  # deq test
+  #
+  
+  def test_deq_returns_the_next_executable_task_and_inputs
+    queue.enq not_executable, :a,:b,:c
+    queue.enq t,1,2,3
+    
+    assert_equal [t, [1,2,3]], queue.deq
+    assert !queue.empty?
+  end
+  
+  def test_deq_returns_the_specified_task_even_if_not_executable
+    queue.enq t,1,2,3
+    queue.enq not_executable, :a,:b,:c
+    
+    assert_equal [not_executable, [:a,:b,:c]], queue.deq(not_executable)
+    assert !queue.empty?
+  end
+  
+  def test_deq_with_no_inputs_returns_empty_array_as_inputs
+    queue.enq t
+    assert_equal [t, []], queue.deq
+  end
+
+  #
+  # peek test
+  #
+  
+  def test_peek_returns_the_next_executable_task_and_does_not_dequeue_the_task 
+    queue.enq not_executable
+    queue.enq t
+    
+    assert_equal t, queue.peek
+    assert_equal 2, queue.size
+  end
+  
+  def test_peek_returns_nil_if_no_tasks_are_executable
+    assert_equal nil, queue.peek
+    
+    queue.enq not_executable
+
+    assert_equal nil, queue.peek
+  end
+  
+  #
+  # num_executable test
+  #
+  
+  def test_num_executable_returns_number_of_queued_executable_tasks
+    assert_equal 0, queue.num_executable
+    queue.enq not_executable
+    assert_equal 0, queue.num_executable
+    queue.enq t
+    assert_equal 1, queue.num_executable
+  end
+  
+  def test_num_not_executable_returns_number_of_queued_non_executable_tasks
+    assert_equal 0, queue.num_not_executable
+    queue.enq t
+    assert_equal 0, queue.num_not_executable
+    queue.enq not_executable
+    assert_equal 1, queue.num_not_executable
+  end
+end