test-unit 3.2.0 → 3.3.6

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
@@ -136,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

@@ -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,7 @@ 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 :runner, :collector
 
       def initialize(standalone)
@@ -189,7 +193,7 @@ 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,
                "Use the given RUNNER.",
@@ -242,57 +246,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
-              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,
                "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
@@ -495,6 +503,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/load.rb

@@ -111,7 +111,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 +131,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 +164,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 +178,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/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