activegroonga 0.0.7 → 1.0.0

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

@@ -60,6 +60,10 @@ module Test
       def to_s
         long_display
       end
+
+      def critical?
+        true
+      end
     end
 
     module ErrorHandler

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

@@ -11,16 +11,23 @@ module Test
     # when an assertion fails.
     class Failure
       attr_reader :test_name, :location, :message
-      
+      attr_reader :expected, :actual, :user_message
+      attr_reader :inspected_expected, :inspected_actual
+
       SINGLE_CHARACTER = 'F'
       LABEL = "Failure"
 
       # Creates a new Failure 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
+        @expected = options[:expected]
+        @actual = options[:actual]
+        @inspected_expected = options[:inspected_expected]
+        @inspected_actual = options[:inspected_actual]
+        @user_message = options[:user_message]
       end
       
       # Returns a single character representation of a failure.
@@ -51,6 +58,19 @@ module Test
       def to_s
         long_display
       end
+
+      def critical?
+        true
+      end
+
+      def diff
+        @diff ||= compute_diff
+      end
+
+      private
+      def compute_diff
+        Assertions::AssertionMessage.delayed_diff(@expected, @actual).inspect
+      end
     end
 
     module FailureHandler
@@ -64,12 +84,18 @@ module Test
       def handle_assertion_failed_error(exception)
         return false unless exception.is_a?(AssertionFailedError)
         problem_occurred
-        add_failure(exception.message, exception.backtrace)
+        add_failure(exception.message, exception.backtrace,
+                    :expected => exception.expected,
+                    :actual => exception.actual,
+                    :inspected_expected => exception.inspected_expected,
+                    :inspected_actual => exception.inspected_actual,
+                    :user_message => exception.user_message)
         true
       end
 
-      def add_failure(message, backtrace)
-        failure = Failure.new(name, filter_backtrace(backtrace), message)
+      def add_failure(message, backtrace, options={})
+        failure = Failure.new(name, filter_backtrace(backtrace), message,
+                              options)
         current_result.add_failure(failure)
       end
     end

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

@@ -41,6 +41,10 @@ module Test
       def to_s
         long_display
       end
+
+      def critical?
+        false
+      end
     end
 
     class NotifiedError < StandardError
@@ -79,16 +83,16 @@ module Test
     module NotificationHandler
       class << self
         def included(base)
-          base.exception_handler(:handle_Notified_error)
+          base.exception_handler(:handle_notified_error)
         end
       end
 
       private
-      def handle_Notified_error(exception)
+      def handle_notified_error(exception)
         return false unless exception.is_a?(NotifiedError)
         notification = Notification.new(name,
-                                filter_backtrace(exception.backtrace),
-                                exception.message)
+                                        filter_backtrace(exception.backtrace),
+                                        exception.message)
         add_notification(notification)
         true
       end

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

@@ -41,6 +41,10 @@ module Test
       def to_s
         long_display
       end
+
+      def critical?
+        true
+      end
     end
 
     class OmittedError < StandardError
@@ -56,7 +60,7 @@ module Test
         end
       end
 
-      # Omit the test of part of the test.
+      # Omit the test or part of the test.
       #
       # Example:
       #   def test_omission
@@ -80,12 +84,56 @@ module Test
         end
       end
 
+      # Omit the test or part of the test if _condition_ is
+      # true.
+      #
+      # Example:
+      #   def test_omission
+      #     omit_if("".empty?)
+      #     # Not reached here
+      #   end
+      #
+      #   def test_omission_with_here
+      #     omit_if(true) do
+      #       # Not ran here
+      #     end
+      #     omit_if(false) do
+      #       # Reached here
+      #     end
+      #     # Reached here too
+      #   end
       def omit_if(condition, *args, &block)
-        omit(*args, &block) if condition
+        if condition
+          omit(*args, &block)
+        else
+          block.call if block
+        end
       end
 
+      # Omit the test or part of the test if _condition_ is
+      # not true.
+      #
+      # Example:
+      #   def test_omission
+      #     omit_unless("string".empty?)
+      #     # Not reached here
+      #   end
+      #
+      #   def test_omission_with_here
+      #     omit_unless(true) do
+      #       # Reached here
+      #     end
+      #     omit_unless(false) do
+      #       # Not ran here
+      #     end
+      #     # Reached here too
+      #   end
       def omit_unless(condition, *args, &block)
-        omit(*args, &block) unless condition
+        if condition
+          block.call if block
+        else
+          omit(*args, &block)
+        end
       end
 
       private

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

@@ -41,6 +41,10 @@ module Test
       def to_s
         long_display
       end
+
+      def critical?
+        true
+      end
     end
 
     class PendedError < StandardError

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

@@ -1,6 +1,3 @@
-require "fileutils"
-require "tmpdir"
-
 module Test
   module Unit
     module Priority
@@ -20,6 +17,8 @@ module Test
         end
 
         def enable
+          require "fileutils"
+          require "tmpdir"
           @@enabled = true
         end
 

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

@@ -19,6 +19,7 @@ require 'test/unit/priority'
 require 'test/unit/testsuite'
 require 'test/unit/assertionfailederror'
 require 'test/unit/util/backtracefilter'
+require 'test/unit/util/output'
 require 'test/unit/util/method-owner-finder'
 
 module Test
@@ -82,6 +83,7 @@ module Test
       include Priority
       include Assertions
       include Util::BacktraceFilter
+      include Util::Output
 
       STARTED = name + "::STARTED" # :nodoc:
       FINISHED = name + "::FINISHED" # :nodoc:
@@ -94,10 +96,15 @@ module Test
           DESCENDANTS << sub_class
         end
 
-        @@added_methods = []
+        @@added_methods = {}
         def method_added(name) # :nodoc:
           super
-          @@added_methods << name.to_s
+          added_methods = (@@added_methods[self] ||= [])
+          stringified_name = name.to_s
+          if added_methods.include?(stringified_name)
+            attribute(:redefined, true, {}, stringified_name)
+          end
+          added_methods << stringified_name
         end
 
         # Rolls up all of the test* methods in the fixture into
@@ -191,12 +198,12 @@ module Test
         def shutdown
         end
 
-        @@test_order = AVAILABLE_ORDERS.first
+        @@test_orders = {}
 
         # Returns the current test order. This returns
         # +:alphabetic+ by default.
         def test_order
-          @@test_order
+          @@test_orders[self] || AVAILABLE_ORDERS.first
         end
 
         # Sets the current test order.
@@ -209,7 +216,40 @@ module Test
         # [:defined]
         #   Tests are sorted in defined order.
         def test_order=(order)
-          @@test_order = order
+          @@test_orders[self] = order
+        end
+
+        # Defines a test in declarative syntax.
+        #
+        # The following two test definitions are the same:
+        #
+        #   description "register user"
+        #   def test_register_user
+        #     ...
+        #   end
+        #
+        #   test "register user" do
+        #     ...
+        #   end
+        def test(test_description, &block)
+          normalized_description = test_description.gsub(/[^a-zA-Z\d_]+/, '_')
+          method_name = "test_#{normalized_description}".to_sym
+          define_method(method_name, &block)
+          description(test_description, method_name)
+        end
+
+        # Describes a test.
+        #
+        # The following example associates "register a
+        # normal user" description with "test_register"
+        # test.
+        #
+        #   description "register a normal user"
+        #   def test_register
+        #     ...
+        #   end
+        def description(value, target=nil)
+          attribute(:description, value, {}, target || [])
         end
 
         # :stopdoc:
@@ -233,9 +273,10 @@ module Test
         end
 
         def sort_test_names_in_defined_order(test_names)
+          added_methods = @@added_methods[self]
           test_names.sort do |test1, test2|
-            test1_defined_order = @@added_methods.index(test1)
-            test2_defined_order = @@added_methods.index(test2)
+            test1_defined_order = added_methods.index(test1)
+            test2_defined_order = added_methods.index(test2)
             if test1_defined_order and test2_defined_order
               test1_defined_order <=> test2_defined_order
             elsif test1_defined_order
@@ -374,6 +415,15 @@ module Test
         "#{@method_name}(#{self.class.name})"
       end
 
+      # Returns a description for the test. A description
+      # will be associated by Test::Unit::TestCase.test or
+      # Test::Unit::TestCase.description.
+      #
+      # Returns a name for the test for no description test.
+      def description
+        self[:description] || name
+      end
+
       # Overridden to return #name.
       def to_s
         name
@@ -396,7 +446,11 @@ module Test
       end
 
       def run_test
+        if self.class.get_attribute(@method_name, :redefined)
+          notify("#{self.class}\##{@method_name} was redefined")
+        end
         __send__(@method_name)
+        add_pass
       end
 
       def handle_exception(exception)
@@ -420,6 +474,10 @@ module Test
       def add_assertion
         current_result.add_assertion
       end
+
+      def add_pass
+        current_result.add_pass
+      end
     end
   end
 end

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

@@ -34,11 +34,11 @@ module Test
       CHANGED = "CHANGED"
       FAULT = "FAULT"
 
-      attr_reader :run_count, :assertion_count, :faults
+      attr_reader :run_count, :pass_count, :assertion_count, :faults
 
       # Constructs a new, empty TestResult.
       def initialize
-        @run_count, @assertion_count = 0, 0
+        @run_count, @pass_count, @assertion_count = 0, 0, 0
         @summary_generators = []
         @problem_checkers = []
         @faults = []
@@ -51,6 +51,10 @@ module Test
         notify_changed
       end
 
+      def add_pass
+        @pass_count += 1
+      end
+
       # Records an individual assertion.
       def add_assertion
         @assertion_count += 1
@@ -65,6 +69,25 @@ module Test
          *@summary_generators.collect {|generator| send(generator)}].join(", ")
       end
 
+      # Returnes a string that shows result status.
+      def status
+        if passed?
+          if pending_count > 0
+            "pending"
+          elsif omission_count > 0
+            "omission"
+          elsif notification_count > 0
+            "notification"
+          else
+            "pass"
+          end
+        elsif error_count > 0
+          "error"
+        elsif failure_count > 0
+          "failure"
+        end
+      end
+
       def to_s
         summary
       end
@@ -75,6 +98,15 @@ module Test
         @problem_checkers.all? {|checker| not send(checker)}
       end
 
+      def pass_percentage
+        n_tests = @run_count - omission_count
+        if n_tests.zero?
+          0
+        else
+          100.0 * (@pass_count / n_tests.to_f)
+        end
+      end
+
       private
       def notify_changed
         notify_listeners(CHANGED, self)

data/test-unit/lib/test/unit/ui/console/testrunner.rb

@@ -38,22 +38,14 @@ module Test
             @progress_row_max = @options[:progress_row_max]
             @progress_row_max ||= guess_progress_row_max
             @already_outputted = false
-            @n_successes = 0
             @indent = 0
             @top_level = true
             @faults = []
           end
 
-          # Begins the test run.
-          def start
-            setup_mediator
-            attach_to_mediator
-            return start_mediator
-          end
-
           private
           def setup_mediator
-            @mediator = create_mediator(@suite)
+            super
             output_setup_end
           end
 
@@ -63,10 +55,6 @@ module Test
             output("Loaded suite #{suite_name}")
           end
 
-          def create_mediator(suite)
-            return TestRunnerMediator.new(suite)
-          end
-          
           def attach_to_mediator
             @mediator.add_listener(TestResult::FAULT, &method(:add_fault))
             @mediator.add_listener(TestRunnerMediator::STARTED, &method(:started))
@@ -77,14 +65,10 @@ module Test
             @mediator.add_listener(TestSuite::FINISHED, &method(:test_suite_finished))
           end
           
-          def start_mediator
-            return @mediator.run_suite
-          end
-          
           def add_fault(fault)
             @faults << fault
             output_progress(fault.single_character_display, fault_color(fault))
-            @already_outputted = true
+            @already_outputted = true if fault.critical?
           end
           
           def started(result)
@@ -101,21 +85,72 @@ module Test
             @faults.each_with_index do |fault, index|
               nl
               output_single("%3d) " % (index + 1))
-              label, detail = format_fault(fault).split(/\r?\n/, 2)
-              output(label, fault_color(fault))
-              output(detail)
+              output_fault(fault)
             end
             nl
             output("Finished in #{elapsed_time} seconds.")
             nl
             output(@result, result_color)
-            n_tests = @result.run_count
-            if n_tests.zero?
-              pass_percentage = 0
+            output("%g%% passed" % @result.pass_percentage, result_color)
+          end
+
+          def output_fault(fault)
+            if @use_color and fault.is_a?(Failure) and
+                fault.inspected_expected and fault.inspected_actual
+              output_single(fault.label, fault_color(fault))
+              output(":")
+              output_fault_backtrace(fault)
+              output_fault_message(fault)
             else
-              pass_percentage = 100.0 * (@n_successes / n_tests.to_f)
+              label, detail = format_fault(fault).split(/\r?\n/, 2)
+              output(label, fault_color(fault))
+              output(detail)
+            end
+          end
+
+          def output_fault_backtrace(fault)
+            backtrace = fault.location
+            if backtrace.size == 1
+              output(fault.test_name +
+                     backtrace[0].sub(/\A(.+:\d+).*/, ' [\\1]') +
+                     ":")
+            else
+              output(fault.test_name)
+              backtrace.each_with_index do |entry, i|
+                if i.zero?
+                  prefix = "["
+                  postfix = ""
+                elsif i == backtrace.size - 1
+                  prefix = " "
+                  postfix = "]:"
+                else
+                  prefix = " "
+                  postfix = ""
+                end
+                output("    #{prefix}#{entry}#{postfix}")
+              end
+            end
+          end
+
+          def output_fault_message(fault)
+            output(fault.user_message) if fault.user_message
+            output_single("<")
+            output_single(fault.inspected_expected, color("pass"))
+            output("> expected but was")
+            output_single("<")
+            output_single(fault.inspected_actual, color("failure"))
+            output(">")
+            from, to = prepare_for_diff(fault.expected, fault.actual)
+            if from and to
+              differ = ColorizedReadableDiffer.new(from.split(/\r?\n/),
+                                                   to.split(/\r?\n/),
+                                                   self)
+              if differ.need_diff?
+                output("")
+                output("diff:")
+                differ.diff
+              end
             end
-            output("%g%% passed" % pass_percentage, result_color)
           end
 
           def format_fault(fault)
@@ -129,15 +164,14 @@ module Test
             right_space = 8 * 2
             left_space = @progress_row_max - right_space
             left_space = left_space - indent.size - name.size
-            tab_stop = "\t" * ((left_space - 1) / 8)
+            tab_stop = "\t" * ([left_space - 1, 0].max / 8)
             output_single("#{indent}#{name}:#{tab_stop}", nil, VERBOSE)
             @test_start = Time.now
           end
 
           def test_finished(name)
             unless @already_outputted
-              @n_successes += 1
-              output_progress(".", color("success"))
+              output_progress(".", color("pass"))
             end
             @already_outputted = false
 
@@ -213,7 +247,10 @@ module Test
           end
 
           def color(name)
-            @color_scheme[name] || ColorScheme.default[name]
+            _color = @color_scheme[name]
+            _color ||= @color_scheme["success"] if name == "pass"
+            _color ||= ColorScheme.default[name]
+            _color
           end
 
           def fault_color(fault)
@@ -221,21 +258,7 @@ module Test
           end
 
           def result_color
-            if @result.passed?
-              if @result.pending_count > 0
-                color("pending")
-              elsif @result.omission_count > 0
-                color("omission")
-              elsif @result.notification_count > 0
-                color("notification")
-              else
-                color("success")
-              end
-            elsif @result.error_count > 0
-              color("error")
-            elsif @result.failure_count > 0
-              color("failure")
-            end
+            color(@result.status)
           end
 
           def guess_color_availability
@@ -268,6 +291,135 @@ module Test
             0
           end
         end
+
+        class ColorizedReadableDiffer < Diff::ReadableDiffer
+          def initialize(from, to, runner)
+            @runner = runner
+            super(from, to)
+          end
+
+          def need_diff?(options={})
+            operations.each do |tag,|
+              return true if [:replace, :equal].include?(tag)
+            end
+            false
+          end
+
+          private
+          def output_single(something, color=nil)
+            @runner.send(:output_single, something, color)
+          end
+
+          def output(something, color=nil)
+            @runner.send(:output, something, color)
+          end
+
+          def color(name)
+            @runner.send(:color, name)
+          end
+
+          def cut_off_ratio
+            0
+          end
+
+          def default_ratio
+            0
+          end
+
+          def tag(mark, color_name, contents)
+            _color = color(color_name)
+            contents.each do |content|
+              output_single(mark, _color)
+              output_single(" ")
+              output(content)
+            end
+          end
+
+          def tag_deleted(contents)
+            tag("-", "diff-deleted-tag", contents)
+          end
+
+          def tag_inserted(contents)
+            tag("+", "diff-inserted-tag", contents)
+          end
+
+          def tag_equal(contents)
+            tag(" ", "normal", contents)
+          end
+
+          def tag_difference(contents)
+            tag("?", "diff-difference-tag", contents)
+          end
+
+          def diff_line(from_line, to_line)
+            to_operations = []
+            from_line, to_line, _operations = line_operations(from_line, to_line)
+
+            no_replace = true
+            _operations.each do |tag,|
+              if tag == :replace
+                no_replace = false
+                break
+              end
+            end
+
+            output_single("?", color("diff-difference-tag"))
+            output_single(" ")
+            _operations.each do |tag, from_start, from_end, to_start, to_end|
+              from_width = compute_width(from_line, from_start, from_end)
+              to_width = compute_width(to_line, to_start, to_end)
+              case tag
+              when :replace
+                output_single(from_line[from_start...from_end],
+                              color("diff-deleted"))
+                if (from_width < to_width)
+                  output_single(" " * (to_width - from_width))
+                end
+                to_operations << Proc.new do
+                  output_single(to_line[to_start...to_end],
+                                color("diff-inserted"))
+                  if (to_width < from_width)
+                    output_single(" " * (from_width - to_width))
+                  end
+                end
+              when :delete
+                output_single(from_line[from_start...from_end],
+                              color("diff-deleted"))
+                unless no_replace
+                  to_operations << Proc.new {output_single(" " * from_width)}
+                end
+              when :insert
+                if no_replace
+                  output_single(to_line[to_start...to_end],
+                                color("diff-inserted"))
+                else
+                  output_single(" " * to_width)
+                  to_operations << Proc.new do
+                    output_single(to_line[to_start...to_end],
+                                  color("diff-inserted"))
+                  end
+                end
+              when :equal
+                output_single(from_line[from_start...from_end])
+                unless no_replace
+                  to_operations << Proc.new {output_single(" " * to_width)}
+                end
+              else
+                raise "unknown tag: #{tag}"
+              end
+            end
+            output("")
+
+            unless to_operations.empty?
+              output_single("?", color("diff-difference-tag"))
+              output_single(" ")
+              to_operations.each do |operation|
+                operation.call
+              end
+              output("")
+            end
+          end
+        end
       end
     end
   end