tap 0.12.4 → 0.17.0

data/lib/tap/test/file_test_class.rb

@@ -1,15 +0,0 @@
-module Tap
-  module Test
-    
-    # Class methods extending tests which include FileTest.
-    module FileTestClass
-      
-      # The class-level test root (a Tap::Root)
-      attr_accessor :class_test_root
-      
-      # An array of directories to be cleaned up by cleanup
-      attr_accessor :cleanup_dirs
-
-    end
-  end
-end

data/lib/tap/test/regexp_escape.rb

@@ -1,87 +0,0 @@
-require 'tap/test/utils'
-
-module Tap
-  module Test
-
-    # RegexpEscape is a subclass of regexp that escapes all but the text in a
-    # special escape sequence.  This allows the creation of complex regexps
-    # to match, for instance, console output.
-    #
-    # The RegexpEscape.escape (or equivalently the quote) method does the
-    # work; all regexp-active characters are escaped except for characters
-    # enclosed by ':.' and '.:' delimiters.
-    #
-    #   RegexpEscape.escape('reg[exp]+ chars. are(quoted)')       # => 'reg\[exp\]\+\ chars\.\ are\(quoted\)'
-    #   RegexpEscape.escape('these are not: :.a(b*)c.:')          # => 'these\ are\ not:\ a(b*)c'
-    #
-    # In addition, all-period regexps are automatically upgraded to '.*?';
-    # use the '.{n}' notation to specify n arbitrary characters.
-    #
-    #   RegexpEscape.escape('_:..:_:...:_:....:')        # => '_.*?_.*?_.*?'
-    #   RegexpEscape.escape(':..{1}.:')                  # => '.{1}'
-    #
-    # RegexpEscape instances are initialized using the escaped input string
-    # and return the original string upon to_s.
-    #
-    #   str = %q{
-    #   a multiline
-    #   :...:
-    #   example}
-    #   r = RegexpEscape.new(str)
-    #
-    #   r =~ %q{
-    #   a multiline
-    #   matching
-    #   example}  # => true
-    #
-    #   r !~ %q{
-    #   a failing multiline
-    #   example}  # => true
-    #
-    #   r.to_s    # => str
-    #
-    class RegexpEscape < Regexp
-      
-      # matches the escape sequence
-      ESCAPE_SEQUENCE = /:\..*?\.:/
-      
-      class << self
-      
-        # Escapes regexp-active characters in str, except for character
-        # delimited by ':.' and '.:'.  See the class description for
-        # details.
-        def escape(str)
-          substituents = []
-          str.scan(ESCAPE_SEQUENCE) do
-            regexp_str = $&[2...-2]
-            regexp_str = ".*?" if regexp_str =~ /^\.*$/
-            substituents << regexp_str
-          end
-          substituents << ""
-
-          splits = str.split(ESCAPE_SEQUENCE).collect do |split|
-            super(split)
-          end
-          splits << "" if splits.empty?
-          
-          splits.zip(substituents).to_a.flatten.join
-        end
-        
-        # Same as escape.
-        def quote(str)
-          escape(str)
-        end
-      end
-      
-      def initialize(str, *options)
-        super(RegexpEscape.escape(str), *options)
-        @original_str = str
-      end
-      
-      # Returns the original string for self
-      def to_s
-        @original_str
-      end
-    end
-  end
-end

data/lib/tap/test/script_test.rb

@@ -1,46 +0,0 @@
-require 'tap/test/assertions'
-require 'tap/test/script_tester'
-require 'tap/test/subset_test'
-
-module Tap
-  module Test
-    module ScriptTest
-      
-      def self.included(base)
-        super
-        base.send(:include, Tap::Test::SubsetTest)
-        base.send(:include, Tap::Test::Assertions) 
-      end
-      
-      def default_command_path
-        nil
-      end
-      
-      def script_test(test_dir=method_root.root)
-        subset_test("SCRIPT", "s") do
-          Tap::Root.chdir(test_dir, true) do  
-            Utils.with_argv do
-              puts "\n# == #{name}"
-
-              cmd = ScriptTester.new(default_command_path, env_var('stepwise')) do |expected, result, msg|
-                case expected
-                when String
-                  assert_output_equal(expected, result, msg)
-                when Regexp
-                  assert_alike(expected, result, msg)
-                end
-              end
-              
-              yield(cmd)
-            end
-          end
-        end
-      end
-      
-    end
-  end
-end
-
-
-
-

data/lib/tap/test/script_tester.rb

@@ -1,115 +0,0 @@
-require 'tap/support/shell_utils'
-require 'tap/test/regexp_escape'
-
-module Tap
-  module Test
-
-    class ScriptTester
-      include Tap::Support::ShellUtils
-      
-      # The command path for self, returned by to_s
-      attr_accessor :command_path
-      
-      # An array of (command, message, expected, validation)
-      # entries, representing the accumulated test commands.
-      attr_reader :commands
-      
-      attr_reader :stepwise, :run_block
-      
-      NIL_VALIDATION = lambda {|*args|}
-      
-      def initialize(command_path=nil, stepwise=false, &run_block)
-        @command_path = command_path
-        @commands = []
-        @stepwise = stepwise
-        @run_block = run_block
-      end
-      
-      # Splits the input string, collecting single-line commands
-      # and expected results.  Nil will be used as the expected
-      # result if the result is whitespace, or not present.
-      #
-      #   cmd = ScriptTest.new
-      #   cmd.split %Q{
-      #   % command one
-      #   expected text for command one
-      #   % command two
-      #   % command three
-      #   expected text for command three
-      #   }  
-      #   # => [
-      #   # ["command one", "expected text for command one\n"],
-      #   # ["command two", nil],
-      #   # ["command three", "expected text for command three\n"]] 
-      #
-      def split(str)
-        str.split(/^%\s*/).collect do |s| 
-          next(nil) if s.strip.empty?
-          command, expected = s.split(/\n/, 2)
-          expected = nil if expected && expected.strip.empty?
-          [command.strip, expected]
-        end.compact
-      end
-      
-      def time(msg, command)
-        run([command, msg, nil, NIL_VALIDATION])
-      end
-      
-      def check(msg, command, use_regexp_escapes=true, &validation)
-        new_commands = split(command)
-        commands = new_commands.collect do |cmd, expected|
-          expected = RegexpEscape.new(expected) if expected && use_regexp_escapes
-          [cmd, msg, expected, validation]
-        end
-        
-        run(*commands)
-      end
-
-      def match(msg, command, regexp=nil, &validation)
-        new_commands = split(command)
-        commands = new_commands.collect do |cmd, expected|
-          raise "expected text specified in match command" unless expected == nil
-          [cmd, msg, regexp, validation]
-        end
-        
-        run(*commands)
-      end
-      
-      def run(*commands)
-        commands.each_with_index do |(cmd, msg, expected, validation), i|
-          unless expected || validation
-            raise ArgumentError, "no expectation or validation set for: #{cmd}"
-          end
-          
-          start = Time.now
-          result = capture_sh(cmd) {|ok, status, tempfile_path| }
-          elapsed = Time.now - start
-          
-          cmd_msg = commands.length > 1 ? "#{msg} (#{i})" : msg
-          run_block.call(expected, result, %Q{#{cmd_msg}\n% #{cmd}}) if expected
-          validation.call(result) if validation
-
-          if stepwise
-            print %Q{
-------------------------------------
-%s
-> %s
-%s
-Time Elapsed: %.3fs} % [cmd_msg, cmd, result, elapsed]
-
-            print "\nContinue? (y/n): "
-            break if gets.strip =~ /^no?$/i
-          else
-            puts "%.3fs : %s" % [elapsed, cmd_msg]
-          end
-        end
-      end
-    
-      # Returns the command path.
-      def to_s
-        command_path
-      end
-
-    end
-  end
-end

data/lib/tap/test/subset_test.rb

@@ -1,260 +0,0 @@
-require 'benchmark'
-require 'tap/test/subset_test_class'
-
-module Tap
-  module Test
-    
-    # SubsetTest provides methods to conditionally run tests, or to skip a 
-    # test suite entirely.
-    # 
-    #   require 'tap/test'
-    #
-    #   class Test::Unit::TestCase
-    #     # only true if running on windows
-    #     condition(:windows) { match_platform?('mswin') }
-    # 
-    #     # only true if running on anything but windows
-    #     condition(:non_windows) { match_platform?('non_mswin') }
-    #   end
-    # 
-    #   class WindowsOnlyTest < Test::Unit::TestCase
-    #     skip_test unless satisfied?(:windows)
-    #   end
-    # 
-    # Here the WindowsOnlyTest will only run on a Windows platform. Conditions
-    # like these may be targeted at specific tests when only some tests need 
-    # to be skipped.
-    # 
-    #   class RunOnlyAFewTest < Test::Unit::TestCase
-    #     include SubsetTest
-    # 
-    #     def test_runs_all_the_time
-    #       assert true
-    #     end
-    # 
-    #     def test_runs_only_if_non_windows_condition_is_true
-    #       condition_test(:non_windows) { assert true }
-    #       end
-    #     end
-    # 
-    #     def test_runs_only_when_ENV_variable_EXTENDED_is_true
-    #       extended_test { assert true }
-    #     end
-    # 
-    #     def test_runs_only_when_ENV_variable_BENCHMARK_is_true
-    #       benchmark_test do |x|
-    #         x.report("init speed") { 10000.times { Object.new } }
-    #       end
-    #     end
-    #
-    #     def test_runs_only_when_ENV_variable_CUSTOM_is_true
-    #       subset_test('CUSTOM') { assert true }
-    #     end
-    #   end
-    # 
-    # In the example, the ENV variables EXTENDED, BENCHMARK, and CUSTOM act as
-    # flags to run specific tests.  If you're running your test using Rake, ENV
-    # variables can be set from the command line like so:
-    # 
-    #   % rake test EXTENDED=true
-    #   % rake test BENCHMARK=true
-    # 
-    # Since tap and rap can run rake tasks as well, these are equivalent:
-    #
-    #   % tap run test EXTENDED=true
-    #   % rap test BENCHMARK=true
-    #
-    # In so far as SubsetTest is concerned, the environment variables are 
-    # case-insensitive.  As in the example, additional ENV-based tests can be 
-    # defined using the subset_test method. To run all tests that get switched 
-    # using an ENV variable, set ALL=true.  
-    #
-    #   # also runs benchmark tests
-    #   % rap test BenchMark=true
-    #
-    #   # runs all tests
-    #   % rap test all=true
-    #
-    # See {Test::Unit::TestCase}[link:classes/Test/Unit/TestCase.html] and
-    # SubsetTestClass for more information.
-    module SubsetTest
-      include Tap::Test::EnvVars
-      
-      def self.included(base)
-        super
-        base.extend SubsetTestClass
-      end
-      
-      # Returns true if the specified conditions are satisfied.
-      def satisfied?(*condition_names)
-        self.class.satisfied?(*condition_names)
-      end
-      
-      # Returns true if the subset type (ex 'BENCHMARK') or 'ALL' is
-      # specified in ENV.
-      def run_subset?(type)
-        self.class.run_subset?(type)
-      end
-
-      # Returns true if the input string matches the regexp specified in 
-      # env_var(type). Returns the default value if 'ALL' is specified in
-      # ENV or type is not specified in ENV.  
-      def match_regexp?(type, str, default=true)
-        return true if env_true?("ALL")
-        return default unless env_var(type)
-    
-        str =~ Regexp.new(env_var(type)) ? true : false
-      end
-
-      # Platform-specific test.  Useful for specifying test that should only 
-      # be run on a subset of platforms.  Prints ' ' if the test is not run.
-      #
-      #   def test_only_on_windows
-      #     platform_test('mswin') { ... }
-      #   end
-      #
-      # See SubsetTestClass#match_platform? for matching details.
-      def platform_test(*platforms)
-        if self.class.match_platform?(*platforms)
-          yield
-        else
-          print ' '
-        end
-      end
-      
-      # Conditonal test.  Only runs if the specified conditions are satisfied.
-      # If no conditons are explicitly set, condition_test only runs if ALL 
-      # conditions for the test are satisfied.
-      # 
-      #   condition(:is_true) { true }
-      #   condition(:is_false) { false }
-      #
-      #   def test_only_if_true_is_satisfied
-      #     condition_test(:is_true) { # runs }
-      #   end
-      #
-      #   def test_only_if_all_conditions_are_satisfied
-      #     condition_test {  # does not run }
-      #   end
-      #
-      # See SubsetTestClass#condition for more details.
-      def condition_test(*condition_names)
-        if self.class.unsatisfied_conditions(*condition_names).empty?
-          yield
-        else
-          print ' '
-        end
-      end
-      
-      # Defines a subset test.  The provided block will only run if:
-      # - the subset type is specified in ENV
-      # - the subset 'ALL' is specified in ENV
-      # - the test method name matches the regexp provided in the 
-      #   <TYPE>_TEST ENV variable
-      #  
-      # Otherwise the block will be skipped and +skip+ will be printed in the
-      # test output.  By default skip is the first letter of +type+.
-      #
-      # For example, with these methods:
-      #
-      #   def test_one
-      #     subset_test('CUSTOM') { assert true }
-      #   end
-      #
-      #   def test_two
-      #     subset_test('CUSTOM') { assert true }
-      #   end
-      #
-      #   Condition                    Tests that get run
-      #   ENV['ALL']=true              test_one, test_two
-      #   ENV['CUSTOM']=true           test_one, test_two
-      #   ENV['CUSTOM_TEST']=test_     test_one, test_two
-      #   ENV['CUSTOM_TEST']=test_one  test_one
-      #   ENV['CUSTOM']=nil            no tests get run
-      # 
-      # If you're running your tests with rake (or rap), ENV variables may be
-      # set from the command line.
-      #
-      #   # all tests
-      #   % rap test all=true
-      #
-      #   # custom subset tests
-      #   % rap test custom=true
-      #
-      #   # just test_one (it is the only test
-      #   # matching the '.est_on.' pattern)
-      #   % rap test custom_test=.est_on.
-      #
-      def subset_test(type, skip=type[0..0].downcase)
-        type = type.upcase
-        type_test = "#{type}_TEST"
-        if run_subset?(type) || env_var(type_test)
-          if match_regexp?(type_test, name.to_s)
-            yield
-          else
-            print skip
-          end
-        else
-          print skip
-        end
-      end
-  
-      # Declares a subset_test for the ENV variable 'EXTENDED'.
-      # Prints 'x' if the test is not run.
-      #
-      #   def test_some_long_process
-      #     extended_test { ... }
-      #   end
-      def extended_test(&block) 
-        subset_test("EXTENDED", "x", &block)
-      end
-  
-      # Declares a subset_test for the ENV variable 'BENCHMARK'. If run, 
-      # benchmark_test sets up benchmarking using the Benchmark.bm method 
-      # using the input length and block.  Prints 'b' if the test is not run.
-      #
-      #   include Benchmark
-      #   def test_speed
-      #     benchmark_test(10) {|x| ... }
-      #   end
-      def benchmark_test(length=10, &block) 
-        subset_test("BENCHMARK") do
-          puts
-          puts name
-          Benchmark.bm(length, &block)
-        end
-      end
-
-      # Declares a subset_test for the ENV variable 'PROMPT'. When run, prompts
-      # the user for each input specified in array.  Inputs will then be passed
-      # as a hash to the block.  Prints 'p' unless run.
-      # 
-      #   def test_requiring_inputs
-      #     prompt_test(:a, :b, :c) {|a, b, c| ... }
-      #   end
-      #
-      # If run, the command line prompt will be like the following:
-      #
-      #   test_requiring_inputs: Enter values or 'skip'
-      #   a: avalue
-      #   b: bvalue      
-      #   c: cvalue
-      #
-      # The block recieves ['avalue', 'bvalue', 'cvalue'].  
-      def prompt_test(*keys, &block)
-        subset_test("PROMPT", "p") do
-          puts "\n#{name} -- Enter values or 'skip'."
-  
-          values = keys.collect do |key|
-            print "#{key}: "
-            value = gets.strip
-            flunk "skipped test" if value =~ /skip/i
-            value
-          end
-        
-          yield(*values)
-        end
-      end
-    end
-  end
-end