test-unit 2.0.3 → 2.0.4

data/lib/test/unit/error.rb

@@ -69,18 +69,20 @@ module Test
         end
       end
 
+      NOT_PASS_THROUGH_EXCEPTIONS = []
       PASS_THROUGH_EXCEPTIONS = [NoMemoryError, SignalException, Interrupt,
                                  SystemExit]
       private
       def handle_all_exception(exception)
         case exception
+        when *NOT_PASS_THROUGH_EXCEPTIONS
         when *PASS_THROUGH_EXCEPTIONS
-          false
-        else
-          problem_occurred
-          add_error(exception)
-          true
+          return false
         end
+
+        problem_occurred
+        add_error(exception)
+        true
       end
 
       def add_error(exception)

data/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,15 @@ module Test
       def to_s
         long_display
       end
+
+      def diff
+        @diff ||= compute_diff
+      end
+
+      private
+      def compute_diff
+        Assertions::AssertionMessage.delayed_diff(@expected, @actual).inspect
+      end
     end
 
     module FailureHandler
@@ -64,12 +80,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/lib/test/unit/runner/tap.rb

@@ -0,0 +1,8 @@
+module Test
+  module Unit
+    AutoRunner.register_runner(:tap) do |auto_runner|
+      require 'test/unit/ui/tap/testrunner'
+      Test::Unit::UI::Tap::TestRunner
+    end
+  end
+end

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

@@ -1,7 +1,9 @@
 #--
 #
 # Author:: Nathaniel Talbott.
-# Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
+# Copyright::
+#   * Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
+#   * Copyright (c) 2008-2009 Kouhei Sutou <kou@clear-code.com>
 # License:: Ruby license.
 
 require 'test/unit/color-scheme'
@@ -36,6 +38,9 @@ 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
 
@@ -68,6 +73,8 @@ module Test
             @mediator.add_listener(TestRunnerMediator::FINISHED, &method(:finished))
             @mediator.add_listener(TestCase::STARTED, &method(:test_started))
             @mediator.add_listener(TestCase::FINISHED, &method(:test_finished))
+            @mediator.add_listener(TestSuite::STARTED, &method(:test_suite_started))
+            @mediator.add_listener(TestSuite::FINISHED, &method(:test_suite_finished))
           end
           
           def start_mediator
@@ -91,35 +98,140 @@ module Test
 
           def finished(elapsed_time)
             nl if output?(NORMAL) and !output?(VERBOSE)
-            nl
-            output("Finished in #{elapsed_time} seconds.")
             @faults.each_with_index do |fault, index|
               nl
               output_single("%3d) " % (index + 1))
+              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
+            else
+              pass_percentage = 100.0 * (@n_successes / n_tests.to_f)
+            end
+            output("%g%% passed" % 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
               label, detail = format_fault(fault).split(/\r?\n/, 2)
               output(label, fault_color(fault))
               output(detail)
             end
-            nl
-            output(@result, result_color)
+          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("success"))
+            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
           end
 
           def format_fault(fault)
             fault.long_display
           end
-          
+
           def test_started(name)
-            output_single(name + ": ", nil, VERBOSE)
+            return unless output?(VERBOSE)
+
+            name = name.sub(/\(.+?\)\z/, '')
+            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)
+            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"))
             end
-            nl(VERBOSE)
             @already_outputted = false
+
+            return unless output?(VERBOSE)
+
+            output(": (%f)" % (Time.now - @test_start), nil, VERBOSE)
           end
-          
+
+          def test_suite_started(name)
+            if @top_level
+              @top_level = false
+              return
+            end
+
+            output_single(indent, nil, VERBOSE)
+            if /\A[A-Z]/ =~ name
+              _color = color("case")
+            else
+              _color = color("suite")
+            end
+            output_single(name, _color, VERBOSE)
+            output(": ", nil, VERBOSE)
+            @indent += 2
+          end
+
+          def test_suite_finished(name)
+            @indent -= 2
+          end
+
+          def indent
+            if output?(VERBOSE)
+              " " * @indent
+            else
+              ""
+            end
+          end
+
           def nl(level=NORMAL)
             output("", nil, level)
           end
@@ -213,6 +325,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

data/lib/test/unit/ui/emacs/testrunner.rb

@@ -22,6 +22,20 @@ module Test
             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 do |entry|
+                output(entry)
+              end
+            end
+          end
+
           def format_fault_failure(failure)
             if failure.location.size == 1
               location = failure.location[0]

data/lib/test/unit/ui/tap/testrunner.rb

@@ -0,0 +1,92 @@
+#--
+#
+# Author:: Kouhei Sutou.
+# Copyright:: Copyright (c) 2009 Kouhei Sutou <kou@clear-code.com>.
+# License:: Ruby license.
+
+require 'test/unit/ui/testrunner'
+require 'test/unit/ui/testrunnermediator'
+
+module Test
+  module Unit
+    module UI
+      module Tap
+
+        # Runs a Test::Unit::TestSuite and outputs result
+        # as TAP format.
+        class TestRunner < UI::TestRunner
+          def initialize(suite, options={})
+            super
+            @output = @options[:output] || STDOUT
+            @n_tests = 0
+            @already_outputted = false
+          end
+
+          # Begins the test run.
+          def start
+            setup_mediator
+            result = start_mediator
+            def result.passed?
+              true # for prove commend :<
+            end
+            result
+          end
+
+          private
+          def setup_mediator
+            @mediator = TestRunnerMediator.new(@suite)
+            attach_to_mediator
+          end
+
+          def attach_to_mediator
+            @mediator.add_listener(TestResult::FAULT, &method(:add_fault))
+            @mediator.add_listener(TestRunnerMediator::STARTED, &method(:started))
+            @mediator.add_listener(TestRunnerMediator::FINISHED, &method(:finished))
+            @mediator.add_listener(TestCase::STARTED, &method(:test_started))
+            @mediator.add_listener(TestCase::FINISHED, &method(:test_finished))
+          end
+
+          def start_mediator
+            @mediator.run_suite
+          end
+
+          def add_fault(fault)
+            puts("not ok #{@n_tests} - #{fault.short_display}")
+            fault.long_display.each_line do |line|
+              puts("# #{line}")
+            end
+            @already_outputted = true
+          end
+
+          def started(result)
+            @result = result
+            puts("1..#{@suite.size}")
+          end
+
+          def finished(elapsed_time)
+            puts("# Finished in #{elapsed_time} seconds.")
+            @result.to_s.each_line do |line|
+              puts("# #{line}")
+            end
+          end
+
+          def test_started(name)
+            @n_tests += 1
+          end
+
+          def test_finished(name)
+            unless @already_outputted
+              puts("ok #{@n_tests} - #{name}")
+            end
+            @already_outputted = false
+          end
+
+          def puts(*args)
+            @output.puts(*args)
+            @output.flush
+          end
+        end
+      end
+    end
+  end
+end