test-unit 3.1.4 → 3.6.2

data/lib/test/unit/attribute.rb

@@ -43,12 +43,80 @@ module Test
           kept_attributes = StringifyKeyHash.new
           @current_attributes.each do |attribute_name, attribute|
             attributes[attribute_name] = attribute[:value]
-            kept_attributes[attribute_name] = attribute if attribute[:keep]
+            if attribute[:keep]
+              keep_hook = attribute[:keep_hook]
+              attribute = keep_hook.call(attribute) if keep_hook
+              kept_attributes[attribute_name] = attribute
+            end
           end
           set_attributes(name, attributes)
           @current_attributes = kept_attributes
         end
 
+        # Set an attribute to test methods.
+        #
+        # @overload attribute(name, value)
+        #   @example
+        #     attribute :speed, :slow
+        #     def test_my_slow_method
+        #       self[:speed] # => :slow
+        #     end
+        #
+        #   @param [Object] name the attribute name
+        #   @param [Object] value the attribute value
+        #   @return [void]
+        #
+        # @overload attribute(name, value, *method_names)
+        #   @example
+        #     def test_my_slow_method1
+        #       self[:speed] # => :slow
+        #     end
+        #
+        #     attribute :speed, :slow, :test_my_slow_method1, :test_my_slow_method2
+        #
+        #     def test_my_slow_method2
+        #       self[:speed] # => :slow
+        #     end
+        #
+        #   @param [Object] name the attribute name
+        #   @param [Object] value the attribute value
+        #   @param [Array<Symbol, String>] method_names the test method names set the attribute
+        #   @return [void]
+        #
+        # @overload attribute(name, value, options)
+        #   @example
+        #     attribute :speed, :slow, keep: true
+        #     def test_my_slow_method1
+        #       self[:speed] # => :slow
+        #     end
+        #
+        #     def test_my_slow_method2
+        #       self[:speed] # => :slow
+        #     end
+        #
+        #   @param [Object] name the attribute name
+        #   @param [Object] value the attribute value
+        #   @option options [Boolean] :keep whether or not to set attribute to following test methods
+        #   @return [void]
+        #
+        # @overload attribute(name, value, options, *method_names)
+        #   @example
+        #     def test_my_slow_method1
+        #       self[:speed] # => :slow
+        #     end
+        #
+        #     # There are no valid options for now.
+        #     attribute :speed, :slow, {}, :test_my_slow_method1
+        #
+        #     def test_my_slow_method2
+        #       self[:speed] # => nil
+        #     end
+        #
+        #   @param [Object] name the attribute name
+        #   @param [Object] value the attribute value
+        #   @param [Hash] options ignored
+        #   @param [Array<Symbol, String>] method_names the test method names set the attribute
+        #   @return [void]
         def attribute(name, value, options={}, *method_names)
           unless options.is_a?(Hash)
             method_names << options
@@ -111,7 +179,10 @@ module Test
           attributes || StringifyKeyHash.new
         end
 
-        def find_attribute(method_name, name)
+        def find_attribute(method_name, name, options={})
+          recursive_p = options[:recursive]
+          recursive_p = true if recursive_p.nil?
+
           @attributes_table ||= StringifyKeyHash.new
           if @attributes_table.key?(method_name)
             attributes = @attributes_table[method_name]
@@ -120,6 +191,7 @@ module Test
             end
           end
 
+          return nil unless recursive_p
           return nil if self == TestCase
 
           @cached_parent_test_case ||= ancestors.find do |ancestor|
@@ -127,12 +199,14 @@ module Test
               ancestor.is_a?(Class) and
               ancestor < Test::Unit::Attribute
           end
+          return nil if @cached_parent_test_case.nil?
 
-          @cached_parent_test_case.find_attribute(method_name, name)
+          @cached_parent_test_case.find_attribute(method_name, name, options)
         end
 
         @@attribute_observers = StringifyKeyHash.new
-        def register_attribute_observer(attribute_name, observer=Proc.new)
+        def register_attribute_observer(attribute_name, observer=nil, &block)
+          observer ||= Proc.new(&block)
           @@attribute_observers[attribute_name] ||= []
           @@attribute_observers[attribute_name] << observer
         end

data/lib/test/unit/auto-runner-loader.rb

@@ -0,0 +1,17 @@
+require "test/unit/test-suite-creator"
+
+module Test
+  module Unit
+    module AutoRunnerLoader
+      @loaded = false
+      class << self
+        def check(test_case, method_name)
+          return if @loaded
+          return unless TestSuiteCreator.test_method?(test_case, method_name)
+          require "test/unit"
+          @loaded = true
+        end
+      end
+    end
+  end
+end

data/lib/test/unit/autorunner.rb

@@ -1,7 +1,10 @@
-require 'test/unit/color-scheme'
-require 'test/unit/priority'
-require 'test/unit/attribute-matcher'
-require 'optparse'
+require "English"
+require "optparse"
+
+require "test/unit/color-scheme"
+require "test/unit/priority"
+require "test/unit/attribute-matcher"
+require "test/unit/testcase"
 
 module Test
   module Unit
@@ -12,7 +15,8 @@ module Test
       PREPARE_HOOKS = []
 
       class << self
-        def register_runner(id, runner_builder=Proc.new)
+        def register_runner(id, runner_builder=nil, &block)
+          runner_builder ||= Proc.new(&block)
           RUNNERS[id] = runner_builder
           RUNNERS[id.to_s] = runner_builder
         end
@@ -30,7 +34,8 @@ module Test
           @@default_runner = id
         end
 
-        def register_collector(id, collector_builder=Proc.new)
+        def register_collector(id, collector_builder=nil, &block)
+          collector_builder ||= Proc.new(&block)
           COLLECTORS[id] = collector_builder
           COLLECTORS[id.to_s] = collector_builder
         end
@@ -43,11 +48,13 @@ module Test
           ColorScheme[id] = scheme
         end
 
-        def setup_option(option_builder=Proc.new)
+        def setup_option(option_builder=nil, &block)
+          option_builder ||= Proc.new(&block)
           ADDITIONAL_OPTIONS << option_builder
         end
 
-        def prepare(hook=Proc.new)
+        def prepare(hook=nil, &block)
+          hook ||= Proc.new(&block)
           PREPARE_HOOKS << hook
         end
 
@@ -78,14 +85,14 @@ module Test
       end
 
       register_collector(:descendant) do |auto_runner|
-        require 'test/unit/collector/descendant'
+        require "test/unit/collector/descendant"
         collector = Collector::Descendant.new
         collector.filter = auto_runner.filters
-        collector.collect($0.sub(/\.rb\Z/, ''))
+        collector.collect($0.sub(/\.rb\Z/, ""))
       end
 
       register_collector(:load) do |auto_runner|
-        require 'test/unit/collector/load'
+        require "test/unit/collector/load"
         collector = Collector::Load.new
         unless auto_runner.pattern.empty?
           collector.patterns.replace(auto_runner.pattern)
@@ -94,13 +101,14 @@ module Test
           collector.excludes.replace(auto_runner.exclude)
         end
         collector.base = auto_runner.base
+        collector.default_test_paths = auto_runner.default_test_paths
         collector.filter = auto_runner.filters
         collector.collect(*auto_runner.to_run)
       end
 
       # JUST TEST!
       # register_collector(:xml) do |auto_runner|
-      #   require 'test/unit/collector/xml'
+      #   require "test/unit/collector/xml"
       #   collector = Collector::XML.new
       #   collector.filter = auto_runner.filters
       #   collector.collect(auto_runner.to_run[0])
@@ -108,15 +116,15 @@ module Test
 
       # deprecated
       register_collector(:object_space) do |auto_runner|
-        require 'test/unit/collector/objectspace'
+        require "test/unit/collector/objectspace"
         c = Collector::ObjectSpace.new
         c.filter = auto_runner.filters
-        c.collect($0.sub(/\.rb\Z/, ''))
+        c.collect($0.sub(/\.rb\Z/, ""))
       end
 
       # deprecated
       register_collector(:dir) do |auto_runner|
-        require 'test/unit/collector/dir'
+        require "test/unit/collector/dir"
         c = Collector::Dir.new
         c.filter = auto_runner.filters
         unless auto_runner.pattern.empty?
@@ -127,12 +135,17 @@ module Test
         end
         c.base = auto_runner.base
         $:.push(auto_runner.base) if auto_runner.base
-        c.collect(*(auto_runner.to_run.empty? ? ['.'] : auto_runner.to_run))
+        c.collect(*(auto_runner.to_run.empty? ? ["."] : auto_runner.to_run))
       end
 
       attr_reader :suite, :runner_options
-      attr_accessor :filters, :to_run, :pattern, :exclude, :base, :workdir
+      attr_accessor :filters, :to_run
+      attr_accessor :default_test_paths
+      attr_accessor :pattern, :exclude, :base, :workdir
       attr_accessor :color_scheme, :listeners
+      attr_writer :stop_on_failure
+      attr_writer :debug_on_failure
+      attr_writer :gc_stress
       attr_writer :runner, :collector
 
       def initialize(standalone)
@@ -141,11 +154,15 @@ module Test
         @collector = default_collector
         @filters = []
         @to_run = []
+        @default_test_paths = []
         @color_scheme = ColorScheme.default
         @runner_options = {}
         @default_arguments = []
         @workdir = nil
         @listeners = []
+        @stop_on_failure = false
+        @debug_on_failure = false
+        @gc_stress = false
         config_file = "test-unit.yml"
         if File.exist?(config_file)
           load_config(config_file)
@@ -155,6 +172,14 @@ module Test
         yield(self) if block_given?
       end
 
+      def stop_on_failure?
+        @stop_on_failure
+      end
+
+      def debug_on_failure?
+        @debug_on_failure
+      end
+
       def prepare
         PREPARE_HOOKS.each do |handler|
           handler.call(self)
@@ -164,7 +189,7 @@ module Test
       def process_args(args=ARGV)
         begin
           args.unshift(*@default_arguments)
-          options.order!(args) {|arg| @to_run << arg}
+          options.order!(args) {|arg| add_test_path(arg)}
         rescue OptionParser::ParseError => e
           puts e
           puts options
@@ -176,110 +201,119 @@ module Test
       def options
         @options ||= OptionParser.new do |o|
           o.banner = "Test::Unit automatic runner."
-          o.banner << "\nUsage: #{$0} [options] [-- untouched arguments]"
+          o.banner += "\nUsage: #{$0} [options] [-- untouched arguments]"
 
-          o.on('-r', '--runner=RUNNER', RUNNERS,
+          o.on("-r", "--runner=RUNNER", RUNNERS,
                "Use the given RUNNER.",
                "(" + keyword_display(RUNNERS) + ")") do |r|
             @runner = r
           end
 
-          o.on('--collector=COLLECTOR', COLLECTORS,
+          o.on("--collector=COLLECTOR", COLLECTORS,
                "Use the given COLLECTOR.",
                "(" + keyword_display(COLLECTORS) + ")") do |collector|
             @collector = collector
           end
 
           if (@standalone)
-            o.on('-b', '--basedir=DIR', "Base directory of test suites.") do |b|
+            o.on("-b", "--basedir=DIR", "Base directory of test suites.") do |b|
               @base = b
             end
 
-            o.on('-w', '--workdir=DIR', "Working directory to run tests.") do |w|
+            o.on("-w", "--workdir=DIR", "Working directory to run tests.") do |w|
               @workdir = w
             end
 
-            o.on('-a', '--add=TORUN', Array,
+            o.on("--default-test-path=PATH",
+                 "Add PATH to the default test paths.",
+                 "The PATH is used when user doesn't specify any test path.",
+                 "You can specify this option multiple times.") do |path|
+              @default_test_paths << path
+            end
+
+            o.on("-a", "--add=TORUN", Array,
                  "Add TORUN to the list of things to run;",
-                 "can be a file or a directory.") do |a|
-              @to_run.concat(a)
+                 "can be a file or a directory.") do |paths|
+              paths.each do |path|
+                add_test_path(path)
+              end
             end
 
             @pattern = []
-            o.on('-p', '--pattern=PATTERN', Regexp,
+            o.on("-p", "--pattern=PATTERN", Regexp,
                  "Match files to collect against PATTERN.") do |e|
               @pattern << e
             end
 
             @exclude = []
-            o.on('-x', '--exclude=PATTERN', Regexp,
+            o.on("-x", "--exclude=PATTERN", Regexp,
                  "Ignore files to collect against PATTERN.") do |e|
               @exclude << e
             end
           end
 
-          o.on('-n', '--name=NAME', String,
+          o.on("-n", "--name=NAME", String,
                "Runs tests matching NAME.",
-               "Use '/PATTERN/' for NAME to use regular expression.") do |name|
-            name = (%r{\A/(.*)/\Z} =~ name ? Regexp.new($1) : name)
+               "Use '/PATTERN/' for NAME to use regular expression.",
+               "Regular expression accepts options.",
+               "Example: '/taRget/i' matches 'target' and 'TARGET'") do |name|
+            name = prepare_name(name)
             @filters << lambda do |test|
-              return true if name === test.method_name
-              test_name_without_class_name = test.name.gsub(/\(.+?\)\z/, "")
-              if test_name_without_class_name != test.method_name
-                return true if name === test_name_without_class_name
-              end
-              false
+              match_test_name(test, name)
             end
           end
 
-          o.on('--ignore-name=NAME', String,
+          o.on("--ignore-name=NAME", String,
                "Ignores tests matching NAME.",
-               "Use '/PATTERN/' for NAME to use regular expression.") do |n|
-            n = (%r{\A/(.*)/\Z} =~ n ? Regexp.new($1) : n)
-            case n
-            when Regexp
-              @filters << proc {|t| n =~ t.method_name ? false : true}
-            else
-              @filters << proc {|t| n != t.method_name}
+               "Use '/PATTERN/' for NAME to use regular expression.",
+               "Regular expression accepts options.",
+               "Example: '/taRget/i' matches 'target' and 'TARGET'") do |name|
+            name = prepare_name(name)
+            @filters << lambda do |test|
+              not match_test_name(test, name)
             end
           end
 
-          o.on('-t', '--testcase=TESTCASE', String,
+          o.on("-t", "--testcase=TESTCASE", String,
                "Runs tests in TestCases matching TESTCASE.",
-               "Use '/PATTERN/' for TESTCASE to use regular expression.") do |n|
-            n = (%r{\A/(.*)/\Z} =~ n ? Regexp.new($1) : n)
+               "Use '/PATTERN/' for TESTCASE to use regular expression.",
+               "Regular expression accepts options.",
+               "Example: '/taRget/i' matches 'target' and 'TARGET'") do |name|
+            name = prepare_name(name)
             @filters << lambda do |test|
-              match_test_case_name(test, n)
+              match_test_case_name(test, name)
             end
           end
 
-          o.on('--ignore-testcase=TESTCASE', String,
+          o.on("--ignore-testcase=TESTCASE", String,
                "Ignores tests in TestCases matching TESTCASE.",
-               "Use '/PATTERN/' for TESTCASE to use regular expression.") do |n|
-            n = (%r{\A/(.*)/\Z} =~ n ? Regexp.new($1) : n)
+               "Use '/PATTERN/' for TESTCASE to use regular expression.",
+               "Regular expression accepts options.",
+               "Example: '/taRget/i' matches 'target' and 'TARGET'") do |name|
+            name = prepare_name(name)
             @filters << lambda do |test|
-              not match_test_case_name(test, n)
+              not match_test_case_name(test, name)
             end
           end
 
-          o.on('--location=LOCATION', String,
+          o.on("--location=LOCATION", String,
                "Runs tests that defined in LOCATION.",
-               "LOCATION is one of PATH:LINE, PATH or LINE") do |location|
-            if /\A\d+\z/ =~ location
+               "LOCATION is one of PATH:LINE, PATH or LINE.") do |location|
+            case location
+            when /\A(\d+)\z/
               path = nil
-              line = location.to_i
+              line = $1.to_i
+            when /:(\d+)\z/
+              path = $PREMATCH
+              line = $1.to_i
             else
-              path, line, = location.split(/:(\d+)/, 2)
-              line = line.to_i unless line.nil?
-            end
-            @filters << lambda do |test|
-              test.class.test_defined?(:path => path,
-                                       :line => line,
-                                       :method_name => test.method_name)
+              path = location
+              line = nil
             end
+            add_location_filter(path, line)
           end
 
-          o.on('--attribute=EXPRESSION', String,
+          o.on("--attribute=EXPRESSION", String,
                "Runs tests that matches EXPRESSION.",
                "EXPRESSION is evaluated as Ruby's expression.",
                "Test attribute name can be used with no receiver in EXPRESSION.",
@@ -317,7 +351,7 @@ module Test
             Priority.default = priority
           end
 
-          o.on('-I', "--load-path=DIR[#{File::PATH_SEPARATOR}DIR...]",
+          o.on("-I", "--load-path=DIR[#{File::PATH_SEPARATOR}DIR...]",
                "Appends directory list to $LOAD_PATH.") do |dirs|
             $LOAD_PATH.concat(dirs.split(File::PATH_SEPARATOR))
           end
@@ -330,7 +364,7 @@ module Test
           end
 
           o.on("--config=FILE",
-               "Use YAML fomat FILE content as configuration file.") do |file|
+               "Use YAML format FILE content as configuration file.") do |file|
             load_config(file)
           end
 
@@ -349,27 +383,45 @@ module Test
             assertion_message_class.max_diff_target_string_size = size
           end
 
+          o.on("--[no-]stop-on-failure",
+               "Stops immediately on the first non success test",
+               "(#{@stop_on_failure})") do |boolean|
+            @stop_on_failure = boolean
+          end
+
+          o.on("--[no-]debug-on-failure",
+               "Run debugger if available on failure",
+               "(#{AssertionFailedError.debug_on_failure?})") do |boolean|
+            AssertionFailedError.debug_on_failure = boolean
+          end
+
+          o.on("--[no-]gc-stress",
+               "Enable GC.stress only while each test is running",
+               "(#{@gc_stress})") do |boolean|
+            @gc_stress = boolean
+          end
+
           ADDITIONAL_OPTIONS.each do |option_builder|
             option_builder.call(self, o)
           end
 
-          o.on('--',
+          o.on("--",
                "Stop processing options so that the",
                "remaining options will be passed to the",
                "test."){o.terminate}
 
-          o.on('-h', '--help', 'Display this help.'){puts o; exit}
+          o.on("-h", "--help", "Display this help."){puts o; exit}
 
           o.on_tail
-          o.on_tail('Deprecated options:')
+          o.on_tail("Deprecated options:")
 
-          o.on_tail('--console', 'Console runner (use --runner).') do
+          o.on_tail("--console", "Console runner (use --runner).") do
             warn("Deprecated option (--console).")
             @runner = self.class.runner(:console)
           end
 
           if RUNNERS[:fox]
-            o.on_tail('--fox', 'Fox runner (use --runner).') do
+            o.on_tail("--fox", "Fox runner (use --runner).") do
               warn("Deprecated option (--fox).")
               @runner = self.class.runner(:fox)
             end
@@ -393,7 +445,7 @@ module Test
             n = 1
           end
           i += 1
-          keyword.sub(/^(.{#{n}})([A-Za-z]+)(?=\w*$)/, '\\1[\\2]')
+          keyword.sub(/^(.{#{n}})([A-Za-z-]+)(?=\w*$)/, '\\1[\\2]')
         end.join(", ")
       end
 
@@ -407,13 +459,19 @@ module Test
         @runner_options[:color_scheme] ||= @color_scheme
         @runner_options[:listeners] ||= []
         @runner_options[:listeners].concat(@listeners)
+        if @stop_on_failure
+          @runner_options[:listeners] << StopOnFailureListener.new
+        end
+        if @gc_stress
+          @runner_options[:listeners] << GCStressListener.new
+        end
         change_work_directory do
           runner.run(suite, @runner_options).passed?
         end
       end
 
       def load_config(file)
-        require 'yaml'
+        require "yaml"
         config = YAML.load(File.read(file))
         runner_name = config["runner"]
         @runner = self.class.runner(runner_name) || @runner
@@ -428,7 +486,7 @@ module Test
           if key == :arguments
             @default_arguments.concat(value.split)
           else
-            runner_options[key.to_sym] = value
+            runner_options[key] = value
           end
         end
         @runner_options = @runner_options.merge(runner_options)
@@ -468,6 +526,31 @@ module Test
         end
       end
 
+      def prepare_name(name)
+        case name
+        when /\A\/(.*)\/([imx]*)\z/
+          pattern = $1
+          options_raw = $2
+          options = 0
+          options |= Regexp::IGNORECASE if options_raw.include?("i")
+          options |= Regexp::MULTILINE if options_raw.include?("m")
+          options |= Regexp::EXTENDED if options_raw.include?("x")
+          Regexp.new(pattern, options)
+        else
+          name
+        end
+      end
+
+      def match_test_name(test, pattern)
+        return true if pattern === test.method_name
+        return true if pattern === test.local_name
+        if pattern.is_a?(String)
+          return true if pattern === "#{test.class}##{test.method_name}"
+          return true if pattern === "#{test.class}##{test.local_name}"
+        end
+        false
+      end
+
       def match_test_case_name(test, pattern)
         test.class.ancestors.each do |test_class|
           break if test_class == TestCase
@@ -475,10 +558,49 @@ module Test
         end
         false
       end
+
+      def add_test_path(path)
+        if /:(\d+)\z/ =~ path
+          line = $1.to_i
+          path = $PREMATCH
+          add_location_filter(path, line)
+        end
+        @to_run << path
+      end
+
+      def add_location_filter(path, line)
+        @filters << lambda do |test|
+          test.class.test_defined?(:path => path,
+                                   :line => line,
+                                   :method_name => test.method_name)
+        end
+      end
+
+      class StopOnFailureListener
+        def attach_to_mediator(mediator)
+          mediator.add_listener(TestResult::FINISHED) do |result|
+            result.stop unless result.passed?
+          end
+        end
+      end
+
+      class GCStressListener
+        def attach_to_mediator(mediator)
+          mediator.add_listener(TestCase::STARTED) do |test|
+            GC.start
+            GC.stress = true
+          end
+
+          mediator.add_listener(TestCase::FINISHED) do |test|
+            GC.start
+            GC.stress = false
+          end
+        end
+      end
     end
   end
 end
 
-require 'test/unit/runner/console'
-require 'test/unit/runner/emacs'
-require 'test/unit/runner/xml'
+require "test/unit/runner/console"
+require "test/unit/runner/emacs"
+require "test/unit/runner/xml"

data/lib/test/unit/code-snippet-fetcher.rb

@@ -26,16 +26,16 @@ module Test
       def read_source(path)
         return nil unless File.exist?(path)
         lines = []
-        File.open(path) do |file|
+        File.open(path, "rb") do |file|
           first_line = file.gets
           break if first_line.nil?
-          encoding = detect_encoding(first_line)
-          if encoding
-            first_line.force_encoding(encoding)
-            file.set_encoding(encoding, encoding)
-          end
+          encoding = detect_encoding(first_line) || Encoding::UTF_8
+          first_line.force_encoding(encoding)
           lines << first_line
-          lines.concat(file.readlines)
+          file.each_line do |line|
+            line.force_encoding(encoding)
+            lines << line
+          end
         end
         lines
       end