tap 0.8.0 → 0.9.0

data/test/support/executable_queue_test.rb

@@ -0,0 +1,103 @@
+require  File.join(File.dirname(__FILE__), '../tap_test_helper')
+require 'tap/support/executable_queue'
+
+class ExecutableQueueTest < Test::Unit::TestCase
+  include Tap::Support
+  
+  attr_accessor :m, :queue
+ 
+  def setup
+    @m = Object.new.extend Executable
+    @queue = ExecutableQueue.new
+  end
+  
+  #
+  # initialization tests
+  #
+  
+  def test_initialize
+    q = ExecutableQueue.new
+    assert q.empty?
+  end
+  
+  #
+  # size, clear, empty? tests
+  #
+  
+  def test_size_return_number_of_tasks
+    assert_equal 0, queue.size
+    queue.enq m, []
+    assert_equal 1, queue.size
+  end
+
+  def test_empty_is_true_if_tasks_is_empty
+    assert queue.empty?
+    queue.enq m, []
+    assert !queue.empty?
+  end
+  
+  def test_clear_resets_tasks_and_task_inputs
+    assert_equal([], queue.to_a)
+    
+    queue.enq m, []
+    queue.clear
+    
+    assert_equal([], queue.to_a)
+  end
+  
+  def test_clear_returns_existing_queue_as_an_array
+    assert_equal([], queue.to_a)
+    
+    queue.enq m, []
+    assert_equal [[m, []]], queue.clear
+  end
+  
+  #
+  # queue test
+  #
+  
+  def test_enq_pushes_task_and_inputs_onto_queue
+    assert_equal [], queue.to_a
+    
+    queue.enq(m, [1])
+    assert_equal [[m,[1]]], queue.to_a
+
+    queue.enq(m, [2])
+    assert_equal [[m,[1]], [m,[2]]], queue.to_a
+  end
+  
+  def test_enq_raises_error_for_non_task_methods
+    assert_raise(RuntimeError) { queue.enq(method(:setup), [1]) }
+  end
+  
+  #
+  # unshift test
+  #
+  
+  def test_unshift
+    assert_equal [], queue.to_a
+    
+    queue.unshift(m, [1])
+    assert_equal [[m,[1]]], queue.to_a
+
+    queue.unshift(m, [2])
+    assert_equal [[m,[2]], [m,[1]]], queue.to_a
+  end
+
+  def test_unshift_raises_error_for_non_task_methods
+    assert_raise(RuntimeError) { queue.unshift(method(:setup), [1]) }
+  end
+  
+  #
+  # deq test
+  #
+  
+  def test_deq
+    queue.enq(m, [1])
+    queue.enq(m, [2])
+    
+    assert_equal [m, [1]], queue.deq
+    assert_equal [m, [2]], queue.deq
+  end
+  
+end

data/test/support/executable_test.rb

@@ -0,0 +1,38 @@
+require  File.join(File.dirname(__FILE__), '../tap_test_helper')
+require 'tap/support/executable'
+
+class ExecutableTest < Test::Unit::TestCase
+  include Tap
+
+  attr_accessor :m
+  
+  def setup
+    @m = Tap::Support::Executable.initialize(Object.new, :object_id)
+  end
+  
+  #
+  # initialization tests
+  #
+  
+  def test_initialization
+    assert !m.multithread
+    assert_nil m.on_complete_block
+  end
+  
+  #
+  # on_complete block test
+  #
+  
+  def test_on_complete_sets_on_complete_block
+    block = lambda {}
+    m.on_complete(&block)
+    assert_equal block, m.on_complete_block
+  end
+  
+  def test_on_complete_can_only_be_set_once
+    m.on_complete {}
+    assert_raise(RuntimeError) { m.on_complete {} }
+    assert_raise(RuntimeError) { m.on_complete }
+  end
+
+end

data/test/support/logger_test.rb

@@ -3,29 +3,29 @@ require 'tap/support/logger'
 require 'stringio'
 
 class LoggerTest < Test::Unit::TestCase
-	include Tap
+  include Tap
 
-	#
-	# logger tests
-	#
-	
-	def test_logger
-		output = StringIO.new('')
-		logger = Logger.new(output).extend Support::Logger
-		logger.datetime_format = '%H:%M:%S'
-		logger.subject 'message'
-		
-		assert output.string =~ /^\s+I\[\d\d:\d\d:\d\d\]\s+subject\s+message/, output.string
-	end
+  #
+  # logger tests
+  #
+  
+  def test_logger
+    output = StringIO.new('')
+    logger = Logger.new(output).extend Support::Logger
+    logger.datetime_format = '%H:%M:%S'
+    logger.subject 'message'
+    
+    assert output.string =~ /^\s+I\[\d\d:\d\d:\d\d\]\s+subject\s+message/, output.string
+  end
   
   def test_logdev_returns_the_log_device
-		[StringIO.new(''), STDOUT].each do |device|
-		  logger = Logger.new(device)
+    [StringIO.new(''), STDOUT].each do |device|
+      logger = Logger.new(device)
       assert !logger.respond_to?(:logdev)
       
       logger.extend Support::Logger
       assert_equal Logger::LogDevice, logger.logdev.class
-		  assert_equal device, logger.logdev.dev
+      assert_equal device, logger.logdev.dev
     end
-	end
+  end
 end

data/test/support/rake_test.rb

@@ -17,11 +17,13 @@ class RakeTest < Test::Unit::TestCase
       end
       
       assert_equal [], runlist
-      app.run(:task)
+      app.task(:task).enq
+      app.run
       assert_equal [:prerequisite, :task], runlist
     
       # notice the tasks do not get re-run
-      app.run(:task)
+      app.task(:task).enq
+      app.run
       assert_equal [:prerequisite, :task], runlist
       
       # check that Rake still works natively

data/test/support/shell_utils_test.rb

@@ -0,0 +1,24 @@
+require  File.join(File.dirname(__FILE__), '../tap_test_helper')
+require 'tap/support/shell_utils'
+
+class ShellUtilsTest < Test::Unit::TestCase
+  include Tap::Support::ShellUtils
+
+  #
+  # capture_sh test
+  #
+  
+  def test_capture_sh
+    assert_equal "hello\n", capture_sh('echo hello')
+  end
+  
+  def test_capture_sh_with_block
+    was_in_block = false
+    result = capture_sh('echo hello') do |ok, status|
+      assert ok
+      was_in_block = true
+    end
+    assert_equal "hello\n", result
+    assert was_in_block
+  end
+end

data/test/support/tdoc_test.rb

@@ -9,6 +9,7 @@ require  File.join(File.dirname(__FILE__), '../tap_test_helper')
 class TaskDocumentation < Tap::Task
   config :c_nodoc, 'value'                     # :nodoc:
   config(:c_accessor, 'value')    # c_accessor
+  config(:c_validation, 'value')   {|value| } # c_validation
   
   config_reader  
   
@@ -25,11 +26,12 @@ class TaskDocumentation < Tap::Task
   # c_multiline1
   config(:c_multiline, 'value' )     # c_multiline2
 
-  config :c_with_attr, 'value', {:key => 'value'}               # c_with_attr
-  
   config :alt_c, 'value'                                                           # alt_c
-  config :alt_c_with_attr, 'value', :key => 'value'                    # alt_c_with_attr
+  config :alt_c_validation, 'value'  do |value|  # alt_c_validation
+  end
   config :alt_c_without_value                                                    # alt_c_without_value
+  config :alt_c_validation_without_value   do |value|             # alt_c_validation_without_value
+  end
   
   # declare_config
   declare_config :declare_config
@@ -103,261 +105,266 @@ class TDocTest < Test::Unit::TestCase
   include Tap::Support
     
   TDoc.document(__FILE__)
-
-  #
-  # RDoc RubyLex and RubyToken redefinition test
-  #
-  
-  def test_rubylex_and_rubytoken_redefinition   
-    filepath = __FILE__  
-    tl = RDoc::TopLevel.new(filepath)
-    stats = RDoc::Stats.new
-    options = Options.instance
-    parser = RDoc::RubyParser.new(tl, filepath, File.read(filepath), options, stats)
-    
-    assert Tap::Support::TDoc::ConfigParser.included_modules.include?(RDoc::RubyToken)
-    assert RDoc::RubyParser.included_modules.include?(RDoc::RubyToken)
-    assert_equal RDoc::RubyLex, parser.instance_variable_get("@scanner").class
-    
-    if satisfied?(:irb_variant)
-      assert_not_equal RubyToken, RDoc::RubyToken
-      assert_not_equal RubyLex, RDoc::RubyLex
-      assert RubyLex.included_modules.include?(RubyToken)
-      assert !RubyLex.included_modules.include?(RDoc::RubyLex)
-    else
-      flunk unless !Object.const_defined?(:RubyToken) || RubyToken == RDoc::RubyToken
-      flunk unless !Object.const_defined?(:RubyLex) || RubyLex == RDoc::RubyLex
-    end
-  end
-
-  #
-  # [] tests
-  #
   
-  def test_get_class_documentation
-    c = TDoc[TaskDocumentation]
-    assert_equal RDoc::NormalClass, c.class
-    assert_equal "# = Section One\n# section one\n#\n# == Section Two\n# section two\n# line two\n", c.comment
-    
-    
-    c = TDoc[Nested]
-    assert_equal RDoc::NormalModule, c.class
-    assert_equal "# nested doc\n", c.comment
-    
-    c = TDoc[Nested::Klass]
-    assert_equal RDoc::NormalClass, c.class
-    assert_equal "# class doc\n", c.comment
-    
-    c = TDoc[Nested::Mod]
-    assert_equal RDoc::NormalModule, c.class
-    assert_equal "# mod doc\n", c.comment
-  end
-  
-  def test_get_documentation_works_for_strings_and_constants
-    assert_equal RDoc::NormalClass, TDoc[Nested::Klass].class
-    assert_equal TDoc["Nested::Klass"].object_id, TDoc[Nested::Klass].object_id
-  end
+   #
+   # RDoc RubyLex and RubyToken redefinition test
+   #
+   
+   def test_rubylex_and_rubytoken_redefinition   
+     filepath = __FILE__  
+     tl = RDoc::TopLevel.new(filepath)
+     stats = RDoc::Stats.new
+     options = Options.instance
+     parser = RDoc::RubyParser.new(tl, filepath, File.read(filepath), options, stats)
+     
+     assert Tap::Support::TDoc::ConfigParser.included_modules.include?(RDoc::RubyToken)
+     assert RDoc::RubyParser.included_modules.include?(RDoc::RubyToken)
+     assert_equal RDoc::RubyLex, parser.instance_variable_get("@scanner").class
+     
+     if satisfied?(:irb_variant)
+       assert_not_equal RubyToken, RDoc::RubyToken
+       assert_not_equal RubyLex, RDoc::RubyLex
+       assert RubyLex.included_modules.include?(RubyToken)
+       assert !RubyLex.included_modules.include?(RDoc::RubyLex)
+     else
+       flunk unless !Object.const_defined?(:RubyToken) || RubyToken == RDoc::RubyToken
+       flunk unless !Object.const_defined?(:RubyLex) || RubyLex == RDoc::RubyLex
+     end
+   end
   
-  def test_configs_are_documented
-    c = TDoc[TaskDocumentation]
-    
-    attributes = c.attributes.collect do |attribute|
-      case attribute
-      when TDoc::ConfigAttr
-      {:comment => attribute.original_comment,
-      :name => attribute.name,  
-      :rw => attribute.rw, 
-      :text => attribute.text}
-      else
-        {:comment => attribute.comment,
-        :name => attribute.name,  
-        :rw => attribute.rw, 
-        :text => attribute.text}
-      end
-    end
-    
-    expected_attributes.each_with_index do |expected, i|
-      assert_equal expected, attributes[i], "unequal attribute (index=#{i})"
-    end
-    assert_equal expected_attributes.length, attributes.length
-  end
-  
-  #
-  # accessor extensions
-  #
-  
-  def test_comment_sections
-    c = TDoc[TaskDocumentation]
-    
-    assert c.respond_to?(:comment_sections)
-    assert_equal({
-      "Section One" => "# section one\n#\n",
-      "Section Two" => "# section two\n# line two\n"},
-    c.comment_sections)
-    
-    assert_equal({
-      "Section Two" => "# section two\n# line two\n"},
-    c.comment_sections(/two/i))
-    
-    assert_equal({
-      "Section Two" => "section two\nline two"},
-    c.comment_sections(/two/i, true))
-  end
-  
-  # def test_collect_configurations
-  #   c = TDoc.document(TaskDocumentation, __FILE__)
-  #   assert_equal expected_attributes[0..-5], TDoc.collect_configurations(c)
-  # end
-  # 
-  # def test_collect_attributes
-  #   c = TDoc.document(TaskDocumentation, __FILE__)
-  #   assert_equal expected_attributes[-4..-1], TDoc.collect_attributes(c)
-  # end
-  
-  def expected_attributes 
-    @expected_attributes ||= [{
-    :comment=>nil,
-    :name=>"c_accessor",
-    :rw=>"RW",
-    :text=>"# c_accessor"},
-   {
-    :comment=>nil,
-    :name=>"c_reader",
-    :rw=>"R",
-    :text=>"# c_reader"},
-   {
-    :comment=>nil,
-    :name=>"c",
-    :rw=>nil,
-    :text=>"# c"},
-   {
-    :comment=>"# c_conventional\n",
-    :name=>"c_conventional",
-    :rw=>nil,
-    :text=>""},
-   {
-    :comment=>nil,
-    :name=>"c_without_doc",
-    :rw=>nil,
-    :text=>""},
-   {
-    :comment=>"# c_multiline1\n",
-    :name=>"c_multiline",
-    :rw=>nil,
-    :text=>"# c_multiline2"},
-   {
-    :comment=>nil,
-    :name=>"c_with_attr",
-    :rw=>nil,
-    :text=>"# c_with_attr"},
-   {
-    :comment=>nil,
-    :name=>"alt_c",
-    :rw=>nil,
-    :text=>"# alt_c"},
-   {
-    :comment=>nil,
-    :name=>"alt_c_with_attr",
-    :rw=>nil,
-    :text=>"# alt_c_with_attr"},
-   {
-    :comment=>nil,
-    :name=>"alt_c_without_value",
-    :rw=>nil,
-    :text=>"# alt_c_without_value"},
-   {
-    :comment=>"# declare_config\n",
-    :name=>"declare_config",
-    :rw=>nil,
-    :text=>""},
-   {
-    :comment=>"# confg_accessor\n",
-    :name=>"config_accessor",
-    :rw=>"RW",
-    :text=>""},
-   {
-    :comment=>"# config_reader\n",
-    :name=>"config_reader",
-    :rw=>"R",
-    :text=>""},
-   {
-    :comment=>"# config_writer\n",
-    :name=>"config_writer",
-    :rw=>"W",
-    :text=>""},
-   {
-    :comment=>"# multi_config_accessor\n",
-    :name=>"multi_config_accessor1",
-    :rw=>"RW",
-    :text=>""},
-   {
-    :comment=>"# multi_config_accessor\n",
-    :name=>"multi_config_accessor2",
-    :rw=>"RW",
-    :text=>""},
-   {
-    :comment=>"# attr_accessor\n",
-    :name=>"attr_accessor",
-    :rw=>"RW",
-    :text=>"# ignored"},
-   {
-    :comment=>nil,
-    :name=>"attr_accessor_without_doc",
-    :rw=>"RW",
-    :text=>""},
-   {
-    :comment=>"# multi_attr_accessor\n",
-    :name=>"multi_attr_accessor1",
-    :rw=>"RW",
-    :text=>""},
-   {
-    :comment=>"# multi_attr_accessor\n",
-    :name=>"multi_attr_accessor2",
-    :rw=>"RW",
-    :text=>""}]
-  end
-  
-  #
-  # NotATask documentation
-  #
-  
-  # def test_not_a_task_document
-  #   c = TDoc.document(NotATask, __FILE__)
-  #   
-  #   assert_equal RDoc::NormalClass, c.class
-  #   assert_equal "", c.comment
-  #   
-  #   attributes = c.attributes.collect do |attribute|
-  #     case attribute
-  #     when TDoc::ConfigAttr
-  #     {:comment => attribute.original_comment,
-  #     :name => attribute.name,  
-  #     :rw => attribute.rw, 
-  #     :text => attribute.text}
-  #     else
-  #       {:comment => attribute.comment,
-  #       :name => attribute.name,  
-  #       :rw => attribute.rw, 
-  #       :text => attribute.text}
-  #     end
-  #   end
-  #   
-  #   not_a_task_expected_attributes.each_with_index do |expected, i|
-  #     assert_equal expected, attributes[i], "unequal attribute (index=#{i})"
-  #   end
-  #   assert_equal not_a_task_expected_attributes.length, attributes.length
-  # end
-  
-  def not_a_task_expected_attributes 
-    @not_a_task_expected_attributes ||= [{
-    :comment=>nil,
-    :name=>"is",
-    :rw=>"RW",
-    :text=>""},
-   {
-    :comment=>nil,
-    :name=>"documented",
-    :rw=>"RW",
-    :text=>""}]
-  end
+   #
+   # [] tests
+   #
+   
+   def test_get_class_documentation
+     c = TDoc[TaskDocumentation]
+     assert_equal RDoc::NormalClass, c.class
+     assert_equal "# = Section One\n# section one\n#\n# == Section Two\n# section two\n# line two\n", c.comment
+     
+     
+     c = TDoc[Nested]
+     assert_equal RDoc::NormalModule, c.class
+     assert_equal "# nested doc\n", c.comment
+     
+     c = TDoc[Nested::Klass]
+     assert_equal RDoc::NormalClass, c.class
+     assert_equal "# class doc\n", c.comment
+     
+     c = TDoc[Nested::Mod]
+     assert_equal RDoc::NormalModule, c.class
+     assert_equal "# mod doc\n", c.comment
+   end
+   
+   def test_get_documentation_works_for_strings_and_constants
+     assert_equal RDoc::NormalClass, TDoc[Nested::Klass].class
+     assert_equal TDoc["Nested::Klass"].object_id, TDoc[Nested::Klass].object_id
+   end
+   
+   def test_configs_are_documented
+     c = TDoc[TaskDocumentation]
+     
+     attributes = c.attributes.collect do |attribute|
+       case attribute
+       when TDoc::ConfigAttr
+         {:comment => attribute.original_comment,
+         :name => attribute.name,  
+         :rw => attribute.rw, 
+         :text => attribute.text}
+       else
+         {:comment => attribute.comment,
+         :name => attribute.name,  
+         :rw => attribute.rw, 
+         :text => attribute.text}
+       end
+     end
+     
+     expected_attributes.each_with_index do |expected, i|
+       assert_equal expected, attributes[i], "unequal attribute (index=#{i})"
+     end
+     assert_equal expected_attributes.length, attributes.length
+   end
+   
+   #
+   # accessor extensions
+   #
+   
+   def test_comment_sections
+     c = TDoc[TaskDocumentation]
+     
+     assert c.respond_to?(:comment_sections)
+     assert_equal({
+       "Section One" => "# section one\n#\n",
+       "Section Two" => "# section two\n# line two\n"},
+     c.comment_sections)
+     
+     assert_equal({
+       "Section Two" => "# section two\n# line two\n"},
+     c.comment_sections(/two/i))
+     
+     assert_equal({
+       "Section Two" => "section two\nline two"},
+     c.comment_sections(/two/i, true))
+   end
+   
+   # def test_collect_configurations
+   #   c = TDoc.document(TaskDocumentation, __FILE__)
+   #   assert_equal expected_attributes[0..-5], TDoc.collect_configurations(c)
+   # end
+   # 
+   # def test_collect_attributes
+   #   c = TDoc.document(TaskDocumentation, __FILE__)
+   #   assert_equal expected_attributes[-4..-1], TDoc.collect_attributes(c)
+   # end
+   
+   def expected_attributes 
+     @expected_attributes ||= [{
+     :comment=>nil,
+     :name=>"c_accessor",
+     :rw=>"RW",
+     :text=>"# c_accessor ('value')"},
+    {
+     :comment=>nil,
+     :name=>"c_validation",
+     :rw=>"RW",
+     :text=>"# c_validation ('value')"},
+    {
+     :comment=>nil,
+     :name=>"c_reader",
+     :rw=>"R",
+     :text=>"# c_reader ('value')"},
+    {
+     :comment=>nil,
+     :name=>"c",
+     :rw=>nil,
+     :text=>"# c ('value')"},
+    {
+     :comment=>"# c_conventional\n",
+     :name=>"c_conventional",
+     :rw=>nil,
+     :text=>" ('value')"},
+    {
+     :comment=>nil,
+     :name=>"c_without_doc",
+     :rw=>nil,
+     :text=>" ('value')"},
+    {
+     :comment=>"# c_multiline1\n",
+     :name=>"c_multiline",
+     :rw=>nil,
+     :text=>"# c_multiline2 ('value')"},
+    {
+     :comment=>nil,
+     :name=>"alt_c",
+     :rw=>nil,
+     :text=>"# alt_c ('value')"},
+    {
+     :comment=>nil,
+     :name=>"alt_c_validation",
+     :rw=>nil,
+     :text=>"# alt_c_validation ('value')"},
+    {
+     :comment=>nil,
+     :name=>"alt_c_without_value",
+     :rw=>nil,
+     :text=>"# alt_c_without_value"},
+    {
+     :comment=>nil,
+     :name=>"alt_c_validation_without_value",
+     :rw=>nil,
+     :text=>"# alt_c_validation_without_value"},
+    {
+     :comment=>"# declare_config\n",
+     :name=>"declare_config",
+     :rw=>nil,
+     :text=>""},
+    {
+     :comment=>"# confg_accessor\n",
+     :name=>"config_accessor",
+     :rw=>"RW",
+     :text=>""},
+    {
+     :comment=>"# config_reader\n",
+     :name=>"config_reader",
+     :rw=>"R",
+     :text=>""},
+    {
+     :comment=>"# config_writer\n",
+     :name=>"config_writer",
+     :rw=>"W",
+     :text=>""},
+    {
+     :comment=>"# multi_config_accessor\n",
+     :name=>"multi_config_accessor1",
+     :rw=>"RW",
+     :text=>""},
+    {
+     :comment=>"# multi_config_accessor\n",
+     :name=>"multi_config_accessor2",
+     :rw=>"RW",
+     :text=>""},
+    {
+     :comment=>"# attr_accessor\n",
+     :name=>"attr_accessor",
+     :rw=>"RW",
+     :text=>"# ignored"},
+    {
+     :comment=>nil,
+     :name=>"attr_accessor_without_doc",
+     :rw=>"RW",
+     :text=>""},
+    {
+     :comment=>"# multi_attr_accessor\n",
+     :name=>"multi_attr_accessor1",
+     :rw=>"RW",
+     :text=>""},
+    {
+     :comment=>"# multi_attr_accessor\n",
+     :name=>"multi_attr_accessor2",
+     :rw=>"RW",
+     :text=>""}]
+   end
+   
+   #
+   # NotATask documentation
+   #
+   
+   # def test_not_a_task_document
+   #   c = TDoc.document(NotATask, __FILE__)
+   #   
+   #   assert_equal RDoc::NormalClass, c.class
+   #   assert_equal "", c.comment
+   #   
+   #   attributes = c.attributes.collect do |attribute|
+   #     case attribute
+   #     when TDoc::ConfigAttr
+   #     {:comment => attribute.original_comment,
+   #     :name => attribute.name,  
+   #     :rw => attribute.rw, 
+   #     :text => attribute.text}
+   #     else
+   #       {:comment => attribute.comment,
+   #       :name => attribute.name,  
+   #       :rw => attribute.rw, 
+   #       :text => attribute.text}
+   #     end
+   #   end
+   #   
+   #   not_a_task_expected_attributes.each_with_index do |expected, i|
+   #     assert_equal expected, attributes[i], "unequal attribute (index=#{i})"
+   #   end
+   #   assert_equal not_a_task_expected_attributes.length, attributes.length
+   # end
+   
+   def not_a_task_expected_attributes 
+     @not_a_task_expected_attributes ||= [{
+     :comment=>nil,
+     :name=>"is",
+     :rw=>"RW",
+     :text=>""},
+    {
+     :comment=>nil,
+     :name=>"documented",
+     :rw=>"RW",
+     :text=>""}]
+   end
 end