tap 0.8.0 → 0.9.0

data/lib/tap/test.rb

@@ -1,275 +1,34 @@
-require 'test/unit'
-require 'tap/test/file_methods'
-require 'tap/test/subset_methods'
+require 'tap/test/tap_methods'
 
 module Test # :nodoc:
   module Unit # :nodoc:
+    
+    # Methods extending TestCase.  
+    #
+    # === Method Availability
+    # Note that these methods are added piecemeal by Tap::Test::SubsetMethods, 
+    # Tap::Test::FileMethods and Tap::Test::TapMethods, but that fact doesn't 
+    # come through in the documentation.  Hence, not all of them will be available 
+    # if you're only using SubsetMethods or FileMethods.  Breaks down like this:
+    #
+    #   Using:           Methods Available:
+    #   TapMethods       all
+    #   FileMethods      all, except acts_as_tap_test
+    #   SubsetMethods    all, except acts_as_tap_test, acts_as_file_test, file_test_root
+    #
+    #--
+    #See the TestTutorial for more information.
     class TestCase
-      class << self
-        # Causes a unit test to act as a tap test -- resulting in the following:
-        # - setup using acts_as_file_test
-        # - inclusion of Tap::Test::SubsetMethods
-        # - inclusion of Tap::Test::InstanceMethods 
-        #
-        # Note:  Unless otherwise specified, +acts_as_tap_test+ infers a root directory
-        # based on the calling file. Be sure to specify the root directory explicitly 
-        # if you call acts_as_file_test from a file that is NOT meant to be test file.
-        def acts_as_tap_test(options={})
-          options = {:root => file_test_root}.merge(options.symbolize_keys)
-          acts_as_file_test(options)
-          
-          include Tap::Test::SubsetMethods
-          include Tap::Test::InstanceMethods
-        end
-        
-      end
     end
   end
 end
 
 module Tap
   
-  # == UNDER CONSTRUCTION
+  # Modules facilitating testing.  Tap::Test::TapMethods are specific to
+  # Tap, but the other modules Tap::Test::SubsetMethods and 
+  # Tap::Test::FileMethods are more general in their utility.
   module Test
-
-    # Used during check_audit to hold the sources and values of an audit
-    # in the correct order.  Oriented so that the next value to be checked
-    # is at the top of the stack.
-    class AuditStack # :nodoc:
-      attr_reader :test
-    
-      def initialize(test)
-        @test = test
-        @stack = []
-      end
-    
-      def load_audit(values)
-        [values._sources, values._values].transpose.reverse_each do |sv|
-          load(*sv)
-        end
-      end
-    
-      def load(source, value)
-        @stack.unshift [source, value]
-      end
-    
-      def next
-        @stack.shift
-      end
-    end
-
-    module InstanceMethods # :nodoc:
-
-      # Setup clears the test using clear_tasks and assures that Tap::App.instance 
-      # is the test-specific application.
-      def setup
-        super
-        Tap::App.instance = app
-        app.queue.clear
-      end
-  
-      # Returns the test-specific application.
-      def app 
-        @app ||= Tap::App.new(:root => trs.root, :directories => trs.directories)
-      end
-    
-      # Recieves a hash of task => expected pairs.  Asserts that the last inputs for
-      # each task are equal to the expected inputs.
-      def assert_inputs(hash)
-        hash.each_pair do |task, expected|
-          inputs = task.results.collect { |r| r._input_last(task) }
-          assert_equal expected, inputs
-        end    
-      end
-
-      # Recieves a hash of results => [index, expected] pairs.  Asserts that the task result
-      # inputs at the specified index are equal to the expected inputs.
-      def assert_inputs_by_index(results, hash)
-        hash.each_pair do |index, expected|
-          assert_equal expected, results.collect {|r| r._input(index)}
-        end    
-      end
-    
-      # Recieves a hash of task => expected pairs.  Asserts that the last outputs for
-      # each task are equal to the expected outputs.
-      def assert_outputs(hash)
-        hash.each_pair do |task, expected|
-          outputs = task.results.collect { |r| r._output_last(task) }
-          assert_equal expected, outputs
-        end    
-      end
-    
-      # Recieves a hash of results => [index, expected] pairs.  Asserts that the result
-      # outputs at the specified index are equal to the expected outputs.
-      def assert_outputs_by_index(results, hash)
-        hash.each_pair do |index, expected|
-          assert_equal expected, results.collect {|r| r._output(index)}
-        end    
-      end
-
-      # Recieves an array of audits and a hash of [index, expected_audit] pairs.  Asserts that 
-      # the collection of all [source, value] pairs in the indexed audit matches the corresponding
-      # pairs provided in expected_audit.
-      #
-      # Example:
-      #   a0 = Audit.new('')
-      #   a1 = Audit.new('')
-      #   a1.record(:a, 'a')
-      #   a1.record(:b, 'b')
-      #
-      #   assert_audits([a0, a1], 1 => [[nil, ''], [:a, 'a'], [:b, 'b']]) # => true
-      #
-      # Note that since task results are an array of audits:
-      #    t.results # if => [a0, a1]
-      #    assert_audits(t1.results, 1 => [[nil, ''], [:a, 'a'], [:b, 'b']]) # then => true
-      #
-      def assert_audits(audits, hash)
-        hash.each_pair do |i, expected|
-          audit = audits[i]
-          raise ArgumentError.new("No audit provided at index: #{i}") if audit.nil?
-        
-          actual = [collect_object_ids(audit._source_trail), audit._values].transpose
-          expected = expected.transpose
-          expected[0] = collect_object_ids(expected[0])
-          expected = expected.transpose
-          assert_equal expected, actual, "Unexpected audit for result #{i}.\nAudits displayed as: [[source.object_id, value]]"
-        end
-      end
-    
-      def check_audit(audit, &block)
-        raise "Cannot check audit.  Public method ':_from' already defined for Object." if Object.public_method_defined?(:_from)
-
-        begin
-          audit_stack = AuditStack.new(self)
-          audit_stack.load_audit(audit)
-        
-          # Define the :from testing method.  Defining this method on Object is good for syntax, 
-          # but generally a bad practice.  Hence, the method is undefined immediately after the
-          # test block completes.  
-          #
-          # The from method assumes the object itself is the expected value, and that the expected 
-          # source is given as an argument.  If a block is given to from, that indicates that the value
-          # is the result of a merge -- the block must contain the checks to assert the origins of the
-          # merge value.
-          Object.class_eval %Q{
-            def _from(expected_source=nil, &block)
-              audit_stack = ObjectSpace._id2ref(#{audit_stack.object_id})
-              source, value = audit_stack.next
-
-              if block_given?
-                audit_stack.test.assert_equal Array, source.class, "Expected source from merge."
-                [source, value].transpose.reverse_each do |source, value| 
-                  source.kind_of?(Tap::Support::Audit) ?
-                    audit_stack.load_audit(source) :
-                    audit_stack.load(source, value)
-                end
-                yield
-                source, value = audit_stack.next
-              end  
-        
-              audit_stack.test.assert_equal self, value, "Wrong audit value (be sure your checks are in the correct order)"
-              audit_stack.test.assert_equal expected_source.object_id, source.object_id, PP.singleline_pp(value, "Wrong source id for value: ")
-            end}
-      
-          yield
-        ensure
-          Object.class_eval %Q{remove_method(:_from)} if Object.public_method_defined?(:_from)
-        end
-      end
-
-      # Applies the input options to the specified app for the duration
-      # of the block.  Unless merge_with_existing is false, the input
-      # options will be merged with the existing options; otherwise
-      # the app options will be reconfigured to just the inputs.
-      #
-      #  app = Tap::App.new(:options => {:one => 1, :two => 2})
-      #
-      #  with_options({:one => 'one'}, app) do 
-      #    app.options.marshal_dump     # => {:one => 'one', :two => 2}
-      #  end
-      #  app.options.marshal_dump      # => {:one => 1, :two => 2}
-      #
-      def with_options(options, app=self.app, merge_with_existing=true, &block)
-        app_config = {:options => options}
-        with_config(app_config, app, merge_with_existing, &block)
-      end
-      
-      # Applies the input configurations to the specified app for the 
-      # duration of the block.  Unless merge_with_existing is false,
-      # the input configurations will be merged with the existing 
-      # configurations; otherwise the app will be reconfigured to 
-      # using the inputs as specified.
-      #
-      #  app = Tap::App.new(:directories => {:dir => 'dir', :alt => 'alt_dir'})
-      #  tmp_config = {
-      #    :directories => {:alt => 'another', :new => 'new_dir'},
-      #    :options => {:one => 1}}
-      #
-      #  with_config(tmp_config, app) do 
-      #    app.directories              # => {:dir => 'dir', :alt => 'another', :new => 'new_dir'}
-      #    app.options.marshal_dump     # => {:one => 1}
-      #  end
-      #  app.directories                # => {:dir => 'dir', :alt => 'alt_dir'}
-      #  app.options.marshal_dump       # => {}
-      #
-      def with_config(app_config, app=self.app, merge_with_existing=true, &block)
-        begin
-          hold = app.config
-          if merge_with_existing
-            hold.each_pair do |key, value|
-              next unless app_config.has_key?(key)
-              next unless value.kind_of?(Hash)
-                
-              app_config[key] = value.merge(app_config[key])
-            end
-          end
-          app.reconfigure(app_config)
-
-          yield block if block_given?
-        ensure
-          app.reconfigure(hold)
-        end
-      end
-      
-      # assert_expected_result_files runs the input task using the
-      # input app config, submitting all method input files for 
-      # processing.  the assertions returns true only if all the 
-      # expected and output files are equal.  As such it is very
-      # convenient for file transform tasks.  
-      #
-      # The default application config sets the app root to 
-      # method_root, silences execution and directs app[:data] to
-      # the method output directory.
-      #
-      # assert_expected_result_files makes the input/expected
-      # directories if they do not exist.  By default all the
-      # output files will be cleaned up during teardown. See
-      # FileMethods for more information.
-      def assert_expected_result_files(task, app_config={})
-        make_test_directories
-        
-        app_config = {
-          :root => method_root,
-          :options => {:quiet => true}, 
-          :absolute_paths => {:data => method_filepath(:output)}
-        }.merge(app_config)
-        
-        with_config(app_config, task.app) do
-          assert_output_files_equal do |input_files|
-            output_files = task.execute(*input_files).collect {|a| a._current}
-            block_given? ? yield(output_files) : output_files
-          end
-        end
-      end
-    
-      private    
-    
-      def collect_object_ids(array)
-        array.collect do |s|
-          s.kind_of?(Array) ? collect_object_ids(s) : s.object_id
-        end
-      end
-    end
   end
 end
 

data/lib/tap/test/env_vars.rb

@@ -8,7 +8,9 @@ module Tap
       # if multiple case-insensitive values are defined in ENV.
       def env(type)
         type = type.downcase
-        selected = ENV.select {|key, value| key.downcase == type}
+        
+        # ruby 1.9 returns a hash instead of an array
+        selected = ENV.select {|key, value| key.downcase == type}.to_a
         
         case selected.length
         when 0 then nil
@@ -17,10 +19,10 @@ module Tap
           raise "Multiple env values for '#{type}'" 
         end
       end
-      
-      # Returns true if the env_var(var) is set and matches /^true%/i
-      def env_true?(var)
-        env(var) && env(var) =~ /^true$/i
+      
+      # Returns true if the env_var(var) is set and matches /^true%/i
+      def env_true?(var)
+        env(var) && env(var) =~ /^true$/i
       end
     end
   end

data/lib/tap/test/file_methods.rb

@@ -2,32 +2,29 @@ require 'tap/root'
 require 'tap/test/env_vars'
 require 'test/unit'
 require 'fileutils'
+require 'active_support/core_ext/class'
 
 module Test # :nodoc:
   module Unit # :nodoc:
-    # Methods extending TestCase.  See the TestTutorial for more information.
     class TestCase
       class << self
         
         # Causes a TestCase to act as a file test, by instantiating a class Tap::Root 
-        # (trs), and including the FileMethods.  The root and directories used to 
+        # (trs), and including FileMethods.  The root and directories used to 
         # instantiate trs can be specified as options.  By default file_test_root
-        # and default_directories will be used.
+        # and the directories {:input => 'input', :output => 'output', :expected => 'expected'} 
+        # will be used.
         #
-        #   class FileDependentTest < Test::Unit::TestCase
-        #     acts_as_file_test(:root => file_test_root, :directories => default_directories)
-        #   end
-        #
-        # Note: file_test_root determines a root directory +based on the calling file+.  
+        # Note: file_test_root determines a root directory <em>based on the calling file</em>.  
         # Be sure to specify the root directory explicitly if you call acts_as_file_test
         # from a file that is NOT meant to be test file.
         def acts_as_file_test(options={})
           options = {
             :root => file_test_root,
-            :directories => {}
-          }.merge(options.symbolize_keys)
+            :directories => {:input => 'input', :output => 'output', :expected => 'expected'}
+          }.merge(options)
 
-          directories = default_directories.merge(options[:directories])
+          directories = options[:directories]
           trs = Tap::Root.new(options[:root], directories)
     
           write_inheritable_attribute(:trs, trs)
@@ -35,15 +32,6 @@ module Test # :nodoc:
       
           include Tap::Test::FileMethods
         end
-
-        # The default directories for a file test:
-        #
-        #  :input => 'input'
-        #  :output => 'output'
-        #  :expected => 'expected'
-        def default_directories
-          {:input => 'input', :output => 'output', :expected => 'expected'}
-        end
     
         # Infers the test root directory from the calling file.  Ex:
         #   'some_class.rb' => 'some_class'
@@ -69,80 +57,84 @@ end
 module Tap
   module Test  
     
-    # == Under Construction
+    # == Overview
     #
     # FileMethods sets up a TestCase with methods for accessing and utilizing
-    # test-specific files and directories.  Each class including FileMethods
+    # test-specific files and directories.  Each class that acts_as_file_test
     # is set up with a Tap::Root structure (trs) that mediates the creation of 
-    # test method filepaths.  FileMethods extends TestCase with the 
-    # acts_as_file_test to include the FileMethods and initialize the trs. 
+    # test method filepaths. 
     #
-    #   class FileDependentTest < Test::Unit::TestCase
+    #   class FileMethodsDocTest < Test::Unit::TestCase
     #     acts_as_file_test
-    #
-    #     def test_file_transform
-    #       trs.root                # => "."
-    #       method_root             # => "./file_dependent_test/test_file_transform"
-    #       method_dir(:input)      # => "./file_dependent_test/test_file_transform/input"
+    # 
+    #     def test_something
+    #                           #    dir = File.expand_path( File.dirname(__FILE__) )
+    #       trs.root            # => dir + "/file_methods_doc", 
+    #       method_root         # => dir + "/file_methods_doc/test_something", 
+    #       method_dir(:input)  # => dir + "/file_methods_doc/test_something/input"
     #     end
     #   end
     #
-    # == File Transform Tests
+    # === assert_files
     #
     # FileMethods is specifically designed for tests that transform a set of input 
     # files into output files.  For this type of test, input and expected files can
     # placed into their respective directories then used within the context of
-    # assert_output_files_equal to ensure the output files are equal to the expected
-    # files.
+    # assert_files to ensure the output files are equal to the expected files.
     # 
     # For example, lets define a test that transforms input files into output files
     # in a trivial way, simply by replacing 'input' with 'output' in the file.
     #
-    #   class FileTest < Test::Unit::TestCase
+    #   class FileMethodsDocTest < Test::Unit::TestCase
     #     acts_as_file_test
-    #
-    #     def test_transform
-    #       assert_output_files_equal do |input_files|
+    # 
+    #     def test_sub
+    #       assert_files do |input_files|
     #         input_files.collect do |filepath|
     #           input = File.read(filepath)
-    #           output_file = method_filepath(:ouput_files, File.basename(filepath))
+    #           output_file = method_filepath(:output, File.basename(filepath))
     #
     #           File.open(output_file, "w") do |f|
     #             f << input.gsub(/input/, "output")
     #           end 
+    #
+    #           output_file
     #         end
     #       end
     #     end
     #   end
     #
-    # Now make some input and expected files for the 'test_transform' method:
+    # Now say you had some input and expected files for the 'test_sub' method:
     #
-    #   FileUtils.mkdir_p("file_test/test_transform/input_files")
-    #   FileUtils.mkdir_p("file_test/test_transform/expected_files")
-    #   
-    #   [file_one.txt", file_two.txt"].each_with_index do |basename, i|
-    #     input = "file_test/test_transform/input_files/" + basename
-    #     File.open(input, "w") {|f| f << "test input #{i}"}
+    #   [file_methods_doc/test_sub/input/one.txt]
+    #   test input 1
     #
-    #     expected = "file_test/test_transform/expected_files/" + basename
-    #     File.open(expected, "w") {|f| f << "test output #{i}"}
-    #   end
+    #   [file_methods_doc/test_sub/input/two.txt]
+    #   test input 2
+    #
+    #   [file_methods_doc/test_sub/expected/one.txt]
+    #   test output 1
     #
-    # When you run the FileTest tests, the test_transform test will pass
-    # the existing input_files to the assert_output_files_equal block.  The
-    # block makes output files in "file_test/test_transform/output_files",
-    # and then assert_output_files_equal compares the files and finds they
-    # are equal.  As a result the test passes.
+    #   [file_methods_doc/test_sub/expected/two.txt]
+    #   test output 2
     #
-    # The test fails if you alter the expected file contents, add/remove
-    # expected files, or in some other way make these files unequal.  
+    # When you run the FileMethodsDocTest test, the test_sub test will pass
+    # the input files to the assert_files block.  Then assert_files compares
+    # the returned filepaths with the expected files translated from the 
+    # expected directory to the output directory.  In this case, the files 
+    # are equal and the test passes.
     #
-    # When the test completes, the default teardown method will clean up the
-    # output_files directory.  For ease in debugging, ENV variable flags can 
-    # be specified to keep all output files (KEEP_OUTPUTS) or to keep the 
-    # output files for just the tests that fail (KEEP_FAILURES).  These flags
-    # can easily be specified from the command line when running a rake task:
+    # The test fails if the returned files aren't equal to the expected files,
+    # either because there are missing or extra files, or if the file contents
+    # are different. 
     #
+    # When the test completes, the teardown method cleans up the output directory.  
+    # For ease in debugging, ENV variable flags can be specified to keep all 
+    # output files (KEEP_OUTPUTS) or to keep the output files for just the tests 
+    # that fail (KEEP_FAILURES).  These flags can be specified from the command 
+    # line if you're running the tests with rake or tap:
+    #
+    #   % rake test keep_outputs=true
     #   % tap run test keep_failures=true
     #
     module FileMethods
@@ -156,7 +148,7 @@ module Tap
       # Creates the trs.directories, specific to the method calling make_test_directories
       def make_test_directories
         trs.directories.values.each do |dir| 
-          FileUtils.mkdir_p( File.join(trs.root, method_name, dir) )
+          FileUtils.mkdir_p( File.join(trs.root, method_name_str, dir) )
         end
       end
       
@@ -188,16 +180,21 @@ module Tap
         try_remove_dir(method_root)
         try_remove_dir(trs.root)
       end 
+      
+      # Returns method_name as a string (Ruby 1.9 symbolizes method_name)
+      def method_name_str
+        method_name.to_s
+      end
 
       # The method_root directory is defined as trs.filepath(method_name)
-      def method_root(method=method_name)
+      def method_root(method=method_name_str)
         trs.filepath(method)
       end
 
       # The method directory is defined as 'dir/method', where method is the calling method
       # by default.  method_dir returns the method directory if it exists, otherwise it returns
       # trs[dir].
-      def method_dir(dir, method=method_name)
+      def method_dir(dir, method=method_name_str)
         File.join(method_root(method), trs.directories[dir] || dir.to_s)
       end
     
@@ -209,7 +206,7 @@ module Tap
       end
     
       # Returns a filepath constructed from the method directory if it exists, 
-      #  otherwise the filepath will be constructed from <tt>trs[dir]</tt>. 
+      # otherwise the filepath will be constructed from <tt>trs[dir]</tt>. 
       def method_filepath(dir, *filenames)
         File.join(method_dir(dir), *filenames)
       end
@@ -236,7 +233,7 @@ module Tap
       # files within it.  Raises an error if the removal does not succeed.
       def clear_method_dir(dir)
         # clear out the folder if it exists
-        dir_path = method_dir(dir, method_name)
+        dir_path = method_dir(dir, method_name_str)
         FileUtils.rm_r(dir_path) if File.exists?(dir_path)
       end
       
@@ -260,8 +257,8 @@ module Tap
       # - The extension is chomped off the end of the filename
       # - If the directory for the filepath does not exist, the directory will be created
       # - Like all files in the output directory, tempfiles will be deleted by the default 
-      # +teardown+ method
-      def tempfile(filename=method_name)
+      #   +teardown+ method
+      def output_tempfile(filename=method_name_str)
         n = 0
         ext = File.extname(filename)
         basename = filename.chomp(ext)
@@ -275,88 +272,96 @@ module Tap
         FileUtils.mkdir_p(dirname) unless File.exists?(dirname)
         filepath
       end
-    
-      # Asserts that each pair of input files are equal, using FileUtils.cmp.
-      def files_equal?(a, b)
-        FileUtils.cmp(a, b)
-      end
-    
-      # Asserts that each pair of input files produce an equivalent object when
-      # loaded as a yaml file. 
-      def yml_equal?(a, b)
-        YAML.load_file(a) == YAML.load_file(b)
-      end
 
-      # Yields to the input block for each pair of input files.  An error is raised
-      # if the input arrays do not have equal numbers of entries.
-      def each_pair(a, b, &block)
+      # Yields to the input block for each pair of entries in the input 
+      # arrays.  An error is raised if the input arrays do not have equal 
+      # numbers of entries.
+      def each_pair(a, b, &block) # :yields: entry_a, entry_b,
+        each_pair_with_index(a,b) do |entry_a, entry_b, index|
+          yield(entry_a, entry_b)
+        end
+      end
+      
+      # Same as each_pair but yields the index of the entries as well.
+      def each_pair_with_index(a, b, &block) # :yields: entry_a, entry_b, index
         a = [a] unless a.kind_of?(Array)
         b = [b] unless b.kind_of?(Array)
       
         raise ArgumentError, "The input arrays must have an equal number of entries." unless a.length == b.length
-        a.each_index do |index|
-          yield(a[index], b[index])
+        0.upto(a.length-1) do |index|
+          yield(a[index], b[index], index)
         end
       end
       
-      def assert_output_files_equal(options={}) # :yields: input_files
+      # assert_files runs a file-based test that feeds all files in method_dir(:input) 
+      # to the block, then compares the resulting files (which should be relative to 
+      # method_dir(:output)) with all the files in method_dir(:expected).  Note that
+      # since only the files returned by the block are used in the comparison,
+      # additional files in the output directory are effectively ignored.
+      #
+      # A variety of options can be specified to adjust the behavior:
+      # 
+      #   :input_files                    specify the input files to pass to the block
+      #   :expected_files                 specify the expected files used in comparison
+      #   :include_input_directories      specifies directories to be included in the 
+      #                                     input_files array (by default dirs are excluded)
+      #   :include_expected_directories   specifies directories to be included in the
+      #                                     expected-output file list comparison (by default 
+      #                                     dirs are excluded, note that naturally only files 
+      #                                     have their actual content compared)  
+      #                  
+      # Option keys should be symbols.  assert_files will fail if :expected_files was 
+      # not specified in the options and no files were found in method_dir(:expected).  
+      # This tries to prevent silent false-positive results when you forget to put 
+      # expected files in their place.
+      def assert_files(options={}) # :yields: input_files
         make_test_directories
         
         options = {
           :input_files => nil,
           :expected_files => nil,
-          :require_expected_files => true,
-          :check_for_missing_outputs => true,
-          :iterate_inputs => false,
-          :include_directories => false
+
+          :include_input_directories => false,
+          :include_expected_directories => false
         }.merge(options)
         
-        # set or search for input and expected files, and arrayify
+        # Get the input and expected files in this manner:
+        # - look for manually specified files
+        # - glob for files if none were specified
+        # - expand paths and sort
+        # - remove directories unless specified not to do so
         input_files, expected_files = [:input, :expected].collect do |key|
-          options_key = "#{key}_files".to_sym
-          
-          files = options.delete(options_key)
+          files = options["#{key}_files".to_sym]
           files = method_glob(key) if files.nil?
-          files = (files.kind_of?(Array) ? files : [files])
-          files.collect! {|file| File.expand_path(file) }
-          unless options[:include_directories]
+          files = [files].flatten.collect {|file| File.expand_path(file) }.sort
+
+          unless options["include_#{key}_directories".to_sym]
             files.delete_if {|file| File.directory?(file)} 
           end
+          
           files
         end
-  
-        flunk "No expected files were specfied." if options[:require_expected_files] && expected_files.empty?
-        
-        # create output files
-        output_files = if options[:iterate_inputs]
-          input_files.collect do |input_file|
-            yield(input_file)
-          end
-        else
-          yield(input_files)
-        end
-        output_files = output_files.flatten.collect {|file| File.expand_path(file) }
         
-        if options[:check_for_missing_outputs]
-          expected_output_files = method_glob(:output)
-          unless options[:include_directories]
-            expected_output_files.delete_if {|file| File.directory?(file)} 
-          end
-          expected_output_files.collect! {|file| File.expand_path(file) }
-          
-          # assure there are no missing or extra output files
-          assert_equal expected_output_files, output_files,  "Missing or extra output files" 
+        # check at least one expected file was found
+        if expected_files.empty? && options[:expected_files] == nil
+          flunk "No expected files specified."
         end
+  
+        # get output files from the block, expand and sort
+        output_files = [yield(input_files)].flatten.collect do |output_file| 
+          output_file = File.expand_path(output_file)
+        end.sort
         
         # check that the expected and output filepaths are the same
-        translated_files = output_files.collect {|file| method_translate(file, :output, :expected)}
-        translated_files.collect! {|file| File.expand_path(file) }
-        assert_equal expected_files, translated_files, "Missing or extra expected files"
+        translated_expected_files = expected_files.collect do |expected_file|
+          method_translate(expected_file, :expected, :output)
+        end
+        assert_equal translated_expected_files, output_files, "Missing, extra, or unexpected output files"
 
         # check that the expected and output file contents are equal
         errors = []
         each_pair(expected_files, output_files) do |expected_file, output_file|
-          unless files_equal?(expected_file, output_file)
+          unless (File.directory?(expected_file) && File.directory?(output_file)) || FileUtils.cmp(expected_file, output_file)
             errors << "<#{expected_file}> not equal to\n<#{output_file}>"
           end
         end
@@ -365,7 +370,7 @@ module Tap
 
       private
     
-      def make_tmpname(basename, n, ext="")
+      def make_tmpname(basename, n, ext="") # :nodoc:
         method_filepath(:output, sprintf('%s%d.%d%s', basename, $$, n, ext))
       end
     end