test-unit 3.2.5 → 3.4.7

data/lib/test/unit/attribute.rb

@@ -43,7 +43,11 @@ 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
@@ -200,7 +204,8 @@ module Test
         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/autorunner.rb

@@ -1,10 +1,10 @@
 require "English"
+require "optparse"
 
 require "test/unit/color-scheme"
 require "test/unit/priority"
 require "test/unit/attribute-matcher"
 require "test/unit/testcase"
-require "optparse"
 
 module Test
   module Unit
@@ -15,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
@@ -33,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
@@ -46,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
 
@@ -139,7 +143,8 @@ module Test
       attr_accessor :default_test_paths
       attr_accessor :pattern, :exclude, :base, :workdir
       attr_accessor :color_scheme, :listeners
-      attr_writer :stop_on_failuere
+      attr_writer :stop_on_failure
+      attr_writer :debug_on_failure
       attr_writer :runner, :collector
 
       def initialize(standalone)
@@ -155,6 +160,7 @@ module Test
         @workdir = nil
         @listeners = []
         @stop_on_failure = false
+        @debug_on_failure = false
         config_file = "test-unit.yml"
         if File.exist?(config_file)
           load_config(config_file)
@@ -168,6 +174,10 @@ module Test
         @stop_on_failure
       end
 
+      def debug_on_failure?
+        @debug_on_failure
+      end
+
       def prepare
         PREPARE_HOOKS.each do |handler|
           handler.call(self)
@@ -242,54 +252,61 @@ module Test
 
           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
-              return true if name === test.local_name
-              false
+              match_test_name(test, name)
             end
           end
 
           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,
                "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,
                "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,
                "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?
+              path = location
+              line = nil
             end
             add_location_filter(path, line)
           end
@@ -345,7 +362,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
 
@@ -370,6 +387,12 @@ module Test
             @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
+
           ADDITIONAL_OPTIONS.each do |option_builder|
             option_builder.call(self, o)
           end
@@ -452,7 +475,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)
@@ -492,6 +515,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

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

data/lib/test/unit/collector/descendant.rb

@@ -11,6 +11,7 @@ module Test
         def collect(name=NAME)
           suite = TestSuite.new(name)
           add_test_cases(suite, TestCase::DESCENDANTS)
+          adjust_ractor_tests(suite)
           suite
         end
       end

data/lib/test/unit/collector/dir.rb

@@ -25,9 +25,9 @@ module Test
           basedir = @base
           $:.push(basedir) if basedir
           if(from.empty?)
-            recursive_collect('.', find_test_cases)
+            suite = recursive_collect('.', find_test_cases)
           elsif(from.size == 1)
-            recursive_collect(from.first, find_test_cases)
+            suite = recursive_collect(from.first, find_test_cases)
           else
             suites = []
             from.each do |f|
@@ -38,6 +38,8 @@ module Test
             sort(suites).each{|s| suite << s}
             suite
           end
+          adjust_ractor_tests(suite)
+          suite
         ensure
           $:.delete_at($:.rindex(basedir)) if basedir
         end

data/lib/test/unit/collector/load.rb

@@ -60,6 +60,8 @@ module Test
               test_suite = test_suites.first
             end
 
+            adjust_ractor_tests(test_suite)
+
             test_suite
           end
         end
@@ -111,7 +113,7 @@ module Test
           return if @program_file == expanded_path.to_s
           add_load_path(expanded_path.dirname) do
             begin
-              require(path.basename.to_s)
+              require(expanded_path.to_s)
             rescue LoadError
               @require_failed_infos << {:path => expanded_path, :exception => $!}
             end
@@ -131,8 +133,6 @@ module Test
           return yield if path.nil?
 
           path = path.to_s
-          return yield if $LOAD_PATH.index(path)
-
           begin
             $LOAD_PATH.unshift(path)
             yield
@@ -166,11 +166,11 @@ module Test
           return if @require_failed_infos.empty?
 
           require_failed_infos = @require_failed_infos
-          require_failed_omissions = Class.new(Test::Unit::TestCase)
-          require_failed_omissions.class_eval do
+          require_failed_errors = Class.new(Test::Unit::TestCase)
+          require_failed_errors.class_eval do
             class << self
               def name
-                "RequireFailedOmissions"
+                "RequireFailedErrors"
               end
             end
 
@@ -180,21 +180,18 @@ module Test
               normalized_path = normalized_path.gsub(/\A_+/, '')
               exception = info[:exception]
               define_method("test_require_#{normalized_path}") do
-                @require_failed_exception = exception
-                omit("failed to load: <#{path}>: <#{exception.message}>")
+                raise(exception.class,
+                      "failed to load <#{path}>: #{exception.message}",
+                      exception.backtrace)
               end
             end
 
             def priority
               100
             end
-
-            def filter_backtrace(location)
-              super(@require_failed_exception.backtrace)
-            end
           end
 
-          add_suite(test_suites, require_failed_omissions.suite)
+          add_suite(test_suites, require_failed_errors.suite)
         end
       end
     end

data/lib/test/unit/collector/objectspace.rb

@@ -26,6 +26,7 @@ module Test
             end
           end
           sort(sub_suites).each{|s| suite << s}
+          adjust_ractor_tests(suite)
           suite
         end
       end

data/lib/test/unit/collector.rb

@@ -68,6 +68,37 @@ module Test
           suite << sub_suite
         end
       end
+
+      def adjust_ractor_tests(suite)
+        return if suite.nil?
+        ractor_suites = extract_ractor_tests(suite)
+        ractor_suites.each do |ractor_suite|
+          suite << ractor_suite
+        end
+      end
+
+      def extract_ractor_tests(suite)
+        ractor_suites = []
+        ractor_tests = []
+        suite.tests.each do |test|
+          case test
+          when TestSuite
+            ractor_suites.concat(extract_ractor_tests(test))
+          else
+            next unless test[:ractor]
+            ractor_tests << test
+          end
+        end
+        unless ractor_tests.empty?
+          suite.delete_tests(ractor_tests)
+          ractor_suite = TestSuite.new(suite.name, suite.test_case)
+          ractor_tests.each do |ractor_test|
+            ractor_suite << ractor_test
+          end
+          ractor_suites << ractor_suite
+        end
+        ractor_suites
+      end
     end
   end
 end

data/lib/test/unit/color-scheme.rb

@@ -5,9 +5,25 @@ module Test
     class ColorScheme
       include Enumerable
 
+      TERM_256 = /
+        [+-]256color|
+        \A(?:
+          alacritty|
+          iTerm\s?\d*\.app|
+          kitty|
+          mintty|
+          ms-terminal|
+          nsterm-build\d+|
+          nsterm|
+          terminator|
+          terminology(?:-[0-9.]+)?|
+          termite|
+          vscode
+        )\z/x
+
       class << self
         def default
-          if available_colors == 256
+          if available_colors >= 256
             default_for_256_colors
           else
             default_for_8_colors
@@ -140,7 +156,9 @@ module Test
 
         def guess_available_colors_from_term_env
           case ENV["TERM"]
-          when /-256color\z/
+          when /[+-]direct/
+            2**24
+          when TERM_256
             256
           else
             nil

data/lib/test/unit/data-sets.rb

@@ -0,0 +1,116 @@
+module Test
+  module Unit
+    class DataSets
+      def initialize
+        @variables = []
+        @procs = []
+        @value_sets = []
+      end
+
+      def add(data_set, options=nil)
+        options ||= {}
+        if data_set.respond_to?(:call)
+          @procs << [data_set, options]
+        elsif data_set.is_a?(Array)
+          @variables << [data_set, options]
+        else
+          @value_sets << [data_set, options]
+        end
+      end
+
+      def <<(data_set)
+        add(data_set)
+      end
+
+      def keep
+        new_data_sets = self.class.new
+        all_data_sets = Enumerator.new do |yielder|
+          block = lambda do |(data_set, options)|
+            yielder << [data_set, options]
+          end
+          @procs.each(&block)
+          @variables.each(&block)
+          @value_sets.each(&block)
+        end
+        all_data_sets.each do |data_set, options|
+          next if options.nil?
+          next unless options[:keep]
+          new_data_sets.add(data_set, options)
+        end
+        new_data_sets
+      end
+
+      def each
+        variables = @variables
+        value_sets = @value_sets
+        @procs.each do |proc, options|
+          data_set = proc.call
+          case data_set
+          when Array
+            variables += [[data_set, options]]
+          else
+            value_sets += [[data_set, options]]
+          end
+        end
+
+        value_sets.each do |values, _options|
+          values.each do |label, data|
+            yield(label, data)
+          end
+        end
+
+        each_pattern(variables) do |label, data|
+          yield(label, data)
+        end
+      end
+
+      def ==(other)
+        @variables == other.instance_variable_get(:@variables) and
+          @procs == other.instance_variable_get(:@procs) and
+          @value_sets == other.instance_variable_get(:@value_sets)
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def hash
+        [@variables, @procs, @value_sets].hash
+      end
+
+      private
+      def each_pattern(variables)
+        grouped_variables = variables.group_by do |_, options|
+          options[:group]
+        end
+        grouped_variables.each do |group, group_variables|
+          each_raw_pattern(group_variables) do |cell|
+            label = String.new
+            label << "group: #{group.inspect}" unless group.nil?
+            data = {}
+            cell.each do |variable, pattern|
+              label << ", " unless label.empty?
+              label << "#{variable}: #{pattern.inspect}"
+              data[variable] = pattern
+            end
+            yield(label, data)
+          end
+        end
+      end
+
+      def each_raw_pattern(variables, &block)
+        return if variables.empty?
+
+        sorted_variables = variables.sort_by do |(variable, _), _|
+          variable
+        end
+        all_patterns = sorted_variables.collect do |(variable, patterns), _|
+          patterns.collect do |pattern|
+            [variable, pattern]
+          end
+        end
+        all_patterns[0].product(*all_patterns[1..-1], &block)
+      end
+    end
+  end
+end