test-unit 2.5.1 → 2.5.2

data/lib/test/unit/color.rb

@@ -27,8 +27,15 @@ module Test
       attr_reader :name
       def initialize(name, options={})
         @name = name
-        @foreground = options[:foreground]
-        @foreground = true if @foreground.nil?
+        if options.has_key?(:foreground)
+          if options[:foreground].nil?
+            @background = false
+          else
+            @background = !options[:foreground]
+          end
+        else
+          @background = options[:background]
+        end
         @intensity = options[:intensity]
         @bold = options[:bold]
         @italic = options[:italic]
@@ -36,7 +43,11 @@ module Test
       end
 
       def foreground?
-        @foreground
+        not background?
+      end
+
+      def background?
+        @background
       end
 
       def intensity?
@@ -57,9 +68,9 @@ module Test
 
       def ==(other)
         self.class === other and
-          [name, foreground?, intensity?,
+          [name, background?, intensity?,
            bold?, italic?, underline?] ==
-          [other.name, other.foreground?, other.intensity?,
+          [other.name, other.background?, other.intensity?,
            other.bold?, other.italic?, other.underline?]
       end
 
@@ -70,10 +81,10 @@ module Test
           sequence << "0"
         else
           if NAMES.include?(@name)
-            foreground_parameter = foreground? ? 3 : 4
-            foreground_parameter += 6 if intensity?
+            color_parameter = foreground? ? 3 : 4
+            color_parameter += 6 if intensity?
             color = NAMES.index(@name)
-            sequence << "#{foreground_parameter}#{color}"
+            sequence << "#{color_parameter}#{color}"
           else
             sequence << (foreground? ? "38" : "48")
             sequence << "5"

data/lib/test/unit/error.rb

@@ -15,16 +15,18 @@ module Test
     class Error
       include Util::BacktraceFilter
 
-      attr_reader(:test_name, :exception)
+      attr_reader :test_name, :exception
+      attr_reader :method_name
 
       SINGLE_CHARACTER = 'E'
       LABEL = "Error"
 
       # Creates a new Error with the given test_name and
       # exception.
-      def initialize(test_name, exception)
+      def initialize(test_name, exception, options={})
         @test_name = test_name
         @exception = exception
+        @method_name = options[:method_name]
       end
 
       # Returns a single character representation of an error.
@@ -111,7 +113,8 @@ module Test
       end
 
       def add_error(exception)
-        current_result.add_error(Error.new(name, exception))
+        error = Error.new(name, exception, :method_name => @method_name)
+        current_result.add_error(error)
       end
     end
 

data/lib/test/unit/exceptionhandler.rb

@@ -14,7 +14,7 @@ module Test
             if value
               @@exception_handlers.unshift(method_name)
             else
-              @@exception_handlers -= [method_name]
+              @@exception_handlers.delete(method_name)
             end
           end
           base.register_attribute_observer(:exception_handler, &observer)
@@ -26,12 +26,55 @@ module Test
           ExceptionHandler.exception_handlers
         end
 
-        def exception_handler(*method_names)
-          attribute(:exception_handler, true, *method_names)
+        # @overload exception_handler(method_name)
+        #   Add an exception handler method.
+        #
+        #   @param method_name [Symbol]
+        #      The method name that handles exception raised in tests.
+        #   @return [void]
+        #
+        # @overload exception_handler(&callback)
+        #   Add an exception handler.
+        #
+        #   @yield [test, exception]
+        #     Gives the test and the exception.
+        #   @yieldparam test [Test::Unit::TestCase]
+        #      The test where the exception is raised.
+        #   @yieldparam exception [Exception]
+        #      The exception that is raised in running the test.
+        #   @yieldreturn [Boolean]
+        #      Whether the handler handles the exception or not.
+        #      The handler must return _true_ if the handler handles
+        #      test exception, _false_ otherwise.
+        #   @return [void]
+        #
+        # This is a public API for developers who extend test-unit.
+        def exception_handler(*method_name_or_handlers, &block)
+          if block_given?
+            exception_handlers.unshift(block)
+          else
+            method_name_or_handlers.each do |method_name_or_handler|
+              if method_name_or_handler.respond_to?(:call)
+                handler = method_name_or_handler
+                exception_handlers.unshift(handler)
+              else
+                method_name = method_name_or_handler
+                attribute(:exception_handler, true, {}, method_name)
+              end
+            end
+          end
         end
 
-        def unregister_exception_handler(*method_names)
-          attribute(:exception_handler, false, *method_names)
+        def unregister_exception_handler(*method_name_or_handlers)
+          method_name_or_handlers.each do |method_name_or_handler|
+            if method_name_or_handler.respond_to?(:call)
+              handler = method_name_or_handler
+              exception_handlers.delete(handler)
+            else
+              method_name = method_name_or_handler
+              attribute(:exception_handler, false, {}, method_name)
+            end
+          end
         end
       end
     end

data/lib/test/unit/failure.rb

@@ -11,6 +11,7 @@ module Test
     # when an assertion fails.
     class Failure
       attr_reader :test_name, :location, :message
+      attr_reader :method_name, :source_location
       attr_reader :expected, :actual, :user_message
       attr_reader :inspected_expected, :inspected_actual
 
@@ -23,6 +24,8 @@ module Test
         @test_name = test_name
         @location = location
         @message = message
+        @method_name = options[:method_name]
+        @source_location = options[:source_location]
         @expected = options[:expected]
         @actual = options[:actual]
         @inspected_expected = options[:inspected_expected]
@@ -80,6 +83,42 @@ module Test
         end
       end
 
+      # Report a failure.
+      #
+      # This is a public API for developers who extend test-unit.
+      #
+      # @param message [String] The description about the failure.
+      # @param backtrace [Array<String>] The backtrace for the failure.
+      # @option options [Object] :expected
+      #   The expected value of the assertion.
+      # @option options [Object] :actual
+      #   The actual value of the assertion.
+      # @option options [String] :inspected_expected
+      #   The inspected expected value of the assertion.
+      #   It is used for diff between expected and actual of the failure.
+      # @option options [String] :inspected_actual
+      #   The inspected actual value of the assertion.
+      #   It is used for diff between expected and actual of the failure.
+      # @option options [String] :user_message
+      #   The message of the assertion from user.
+      # @option options [String] :method_name (@method_name)
+      #   The method name of the test.
+      # @option options [Array<String, Integer>] :source_location
+      #   The location where the test is defined. It is the same
+      #   format as Proc#source_location. That is, it's an array of
+      #   path and and line number where the test definition is
+      #   started.
+      # @return [void]
+      def add_failure(message, backtrace, options={})
+        default_options = {
+          :method_name => @method_name,
+          :source_location => self[:source_location],
+        }
+        failure = Failure.new(name, filter_backtrace(backtrace), message,
+                              default_options.merge(options))
+        current_result.add_failure(failure)
+      end
+
       private
       def handle_assertion_failed_error(exception)
         return false unless exception.is_a?(AssertionFailedError)
@@ -92,12 +131,6 @@ module Test
                     :user_message => exception.user_message)
         true
       end
-
-      def add_failure(message, backtrace, options={})
-        failure = Failure.new(name, filter_backtrace(backtrace), message,
-                              options)
-        current_result.add_failure(failure)
-      end
     end
 
     module TestResultFailureSupport

data/lib/test/unit/fault-location-detector.rb

@@ -0,0 +1,95 @@
+# Copyright (C) 2012  Kouhei Sutou <kou@clear-code.com>
+#
+# License: Ruby's
+
+module Test
+  module Unit
+    class FaultLocationDetector
+      def initialize(fault, code_snippet_fetcher)
+        @fault = fault
+        @code_snippet_fetcher = code_snippet_fetcher
+        extract_fault_information
+      end
+
+      def split_backtrace_entry(entry)
+        match_data = /\A(.+):(\d+)(?::(.*))?\z/.match(entry)
+        return nil if match_data.nil?
+        file, line_number, context = match_data.to_a[1..-1]
+        line_number = line_number.to_i
+        if /\Ain `(.+?)'/ =~ context
+          method_name = $1
+        else
+          method_name = nil
+        end
+        [file, line_number, context, method_name]
+      end
+
+      def target?(backtrace_entry)
+        file, line_number, context, method_name =
+          split_backtrace_entry(backtrace_entry)
+        _ = context
+        return false if file.nil?
+
+        if @fault_source_location
+          target_source_location?(file, line_number, method_name)
+        elsif @fault_method_name
+          target_method?(method_name)
+        else
+          true
+        end
+      end
+
+      private
+      def target_source_location?(file, line_number, method_name)
+        fault_file, fault_line_number = @fault_source_location
+        return false unless file.end_with?(fault_file)
+
+        return false if line_number < fault_line_number
+
+        lines = @code_snippet_fetcher.source(file)
+        return false if lines.nil?
+
+        base_indent_level = nil
+        fault_line_number.step(lines.size) do |current_line_number|
+          line = lines[current_line_number - 1]
+          current_indent_level = guess_indent_level(line)
+          base_indent_level ||= current_indent_level
+          return true if current_line_number == line_number
+
+          if current_line_number == fault_line_number
+            break if /(?:\send|\})\s*$/ =~ line
+          else
+            break if current_indent_level == base_indent_level
+          end
+        end
+        false
+      end
+
+      def target_method?(method_name)
+        @fault_method_name == method_name
+      end
+
+      def guess_indent_level(line)
+        if /\A(\s*)/ =~ line
+          $1.sub(/\t/, " " * 8).count(" ")
+        else
+          0
+        end
+      end
+
+      def extract_fault_information
+        if @fault.respond_to?(:source_location)
+          @fault_source_location = @fault.source_location
+        else
+          @fault_source_location = nil
+        end
+
+        if @fault.respond_to?(:method_name)
+          @fault_method_name = @fault.method_name
+        else
+          @fault_method_name = nil
+        end
+      end
+    end
+  end
+end

data/lib/test/unit/notification.rb

@@ -5,16 +5,18 @@ module Test
     class Notification
       include Util::BacktraceFilter
       attr_reader :test_name, :location, :message
+      attr_reader :method_name
 
       SINGLE_CHARACTER = 'N'
       LABEL = "Notification"
 
       # Creates a new Notification with the given location and
       # message.
-      def initialize(test_name, location, message)
+      def initialize(test_name, location, message, options={})
         @test_name = test_name
         @location = location
         @message = message
+        @method_name = options[:method_name]
       end
 
       # Returns a single character representation of a notification.
@@ -74,7 +76,8 @@ module Test
       #   :backtrace override backtrace.
       def notify(message, options={}, &block)
         backtrace = filter_backtrace(options[:backtrace] || caller)
-        notification = Notification.new(name, backtrace, message)
+        notification = Notification.new(name, backtrace, message,
+                                        :method_name => @method_name)
         add_notification(notification)
       end
 

data/lib/test/unit/omission.rb

@@ -5,16 +5,18 @@ module Test
     class Omission
       include Util::BacktraceFilter
       attr_reader :test_name, :location, :message
+      attr_reader :method_name
 
       SINGLE_CHARACTER = 'O'
       LABEL = "Omission"
 
       # Creates a new Omission with the given location and
       # message.
-      def initialize(test_name, location, message)
+      def initialize(test_name, location, message, options={})
         @test_name = test_name
         @location = location
         @message = message
+        @method_name = options[:method_name]
       end
 
       # Returns a single character representation of a omission.
@@ -77,7 +79,8 @@ module Test
       def omit(message=nil, &block)
         message ||= "omitted."
         if block_given?
-          omission = Omission.new(name, filter_backtrace(caller), message)
+          omission = Omission.new(name, filter_backtrace(caller), message,
+                                  :method_name => @method_name)
           add_omission(omission)
         else
           raise OmittedError.new(message)
@@ -154,7 +157,8 @@ module Test
         return false unless exception.is_a?(OmittedError)
         omission = Omission.new(name,
                                 filter_backtrace(exception.backtrace),
-                                exception.message)
+                                exception.message,
+                                :method_name => @method_name)
         add_omission(omission)
         true
       end

data/lib/test/unit/pending.rb

@@ -5,16 +5,18 @@ module Test
     class Pending
       include Util::BacktraceFilter
       attr_reader :test_name, :location, :message
+      attr_reader :method_name
 
       SINGLE_CHARACTER = 'P'
       LABEL = "Pending"
 
       # Creates a new Pending with the given location and
       # message.
-      def initialize(test_name, location, message)
+      def initialize(test_name, location, message, options={})
         @test_name = test_name
         @location = location
         @message = message
+        @method_name = options[:method_name]
       end
 
       # Returns a single character representation of a pending.
@@ -83,7 +85,8 @@ module Test
           begin
             yield
           rescue Exception
-            pending = Pending.new(name, filter_backtrace(caller), message)
+            pending = Pending.new(name, filter_backtrace(caller), message,
+                                  :method_name => @method_name)
             add_pending(pending)
           end
           unless pending
@@ -113,7 +116,8 @@ module Test
         return false unless exception.is_a?(PendedError)
         pending = Pending.new(name,
                               filter_backtrace(exception.backtrace),
-                              exception.message)
+                              exception.message,
+                              :method_name => @method_name)
         add_pending(pending)
         true
       end

data/lib/test/unit/testcase.rb

@@ -116,6 +116,13 @@ module Test
           if _added_methods.include?(stringified_name)
             attribute(:redefined, {:backtrace => caller}, {}, stringified_name)
           end
+          path, line, = caller[0].split(/:(\d+)/,2)
+          line = line.to_i if line
+          method_locations << {
+            :method_name => stringified_name,
+            :path => path,
+            :line => line,
+          }
           _added_methods << stringified_name
         end
 
@@ -262,6 +269,9 @@ module Test
             define_method(method_name, &block)
             description(test_description, method_name)
             attribute(:test, true, {}, method_name)
+            if block.respond_to?(:source_location)
+              attribute(:source_location, block.source_location, {}, method_name)
+            end
           else
             targets = test_description_or_targets
             attribute(:test, true, {}, *targets)
@@ -281,6 +291,98 @@ module Test
         def description(value, target=nil)
           attribute(:description, value, {}, target || [])
         end
+
+        # Defines a sub test case.
+        #
+        # This is a syntax sugar. The both of the following codes are
+        # the same in meaning:
+        #
+        # Standard:
+        #   class TestParent < Test::UnitTestCase
+        #     class TestChild < self
+        #       def test_in_child
+        #       end
+        #     end
+        #   end
+        #
+        # Syntax sugar:
+        #   class TestParent < Test::UnitTestCase
+        #     sub_test_case("TestChild") do
+        #       def test_in_child
+        #       end
+        #     end
+        #   end
+        #
+        # The diffrence of them are the following:
+        #
+        # * Test case created by {sub_test_case} is an anonymous class.
+        #   So you can't refer the test case by name.
+        # * The class name of class style must follow
+        #   constant naming rule in Ruby. But the name of test case
+        #   created by {sub_test_case} doesn't need to follow the rule.
+        #   For example, you can use a space in name such as "child test".
+        #
+        # @param name [String] The name of newly created sub test case.
+        # @yield
+        #   The block is evaludated under the newly created sub test
+        #   case class context.
+        # @return [Test::Unit::TestCase] Created sub test case class.
+        def sub_test_case(name, &block)
+          sub_test_case = Class.new(self) do
+            singleton_class = class << self; self; end
+            singleton_class.send(:define_method, :name) do
+              name
+            end
+          end
+          sub_test_case.class_eval(&block)
+          sub_test_case
+        end
+
+        # Checkes whether a test that is mathched the query is
+        # defined.
+        #
+        # @option query [String] :path (nil)
+        #   the path where a test is defined in.
+        # @option query [Numeric] :line (nil)
+        #   the line number where a test is defined at.
+        # @option query [String] :method_name (nil)
+        #   the method name for a test.
+        def test_defined?(query)
+          query_path = query[:path]
+          query_line = query[:line]
+          query_method_name = query[:method_name]
+
+          available_locations = method_locations
+          if query_path
+            available_locations = available_locations.find_all do |location|
+              location[:path].end_with?(query_path)
+            end
+          end
+          if query_line
+            available_location = available_locations.reverse.find do |location|
+              query_line >= location[:line]
+            end
+            return false if available_location.nil?
+            available_locations = [available_location]
+          end
+          if query_method_name
+            available_location = available_locations.find do |location|
+              query_method_name == location[:method_name]
+            end
+            return false if available_location.nil?
+            available_locations = [available_location]
+          end
+
+          not available_locations.empty?
+        end
+
+        private
+        # @private
+        @@method_locations = {}
+        # @private
+        def method_locations
+          @@method_locations[self] ||= []
+        end
       end
 
       attr_reader :method_name
@@ -546,6 +648,30 @@ module Test
         @internal_data.passed?
       end
 
+      # Notify that a problem is occurred in the test. It means that
+      # the test is a failed test. If any failed tests exist in test
+      # suites, the test process exits with failure exit status.
+      #
+      # This is a public API for developers who extend test-unit.
+      #
+      # @return [void]
+      def problem_occurred
+        @internal_data.problem_occurred
+      end
+
+      # Notify that the test is passed. Normally, it is not needed
+      # because #run calls it automatically. If you want to override
+      # #run, it is not a good idea. Please contact test-unit
+      # developers. We will help you without your custom #run. For
+      # example, we may add a new hook in #run.
+      #
+      # This is a public API for developers who extend test-unit.
+      #
+      # @return [void]
+      def add_pass
+        current_result.add_pass
+      end
+
       private
       def current_result
         @_result
@@ -566,23 +692,20 @@ module Test
 
       def handle_exception(exception)
         self.class.exception_handlers.each do |handler|
-          return true if send(handler, exception)
+          if handler.respond_to?(:call)
+            handled = handler.call(self, exception)
+          else
+            handled = send(handler, exception)
+          end
+          return true if handled
         end
         false
       end
 
-      def problem_occurred
-        @internal_data.problem_occurred
-      end
-
       def add_assertion
         current_result.add_assertion
       end
 
-      def add_pass
-        current_result.add_pass
-      end
-
       class InternalData
         attr_reader :start_time, :elapsed_time
         attr_reader :test_data_label, :test_data