test-unit-ext 0.1.0

data/lib/test-unit-ext/always-show-result.rb

@@ -0,0 +1,28 @@
+require "test/unit/ui/testrunnermediator"
+
+module Test
+  module Unit
+    module UI
+      class TestRunnerMediator
+        alias_method :original_run_suite, :run_suite
+        def run_suite
+          @notified_finished = false
+          begin_time = Time.now
+          original_run_suite
+        rescue Interrupt
+          unless @notified_finished
+            end_time = Time.now
+            elapsed_time = end_time - begin_time
+            notify_listeners(FINISHED, elapsed_time)
+          end
+          raise
+        end
+
+        def notify_listeners(channel_name, *arguments)
+          @notified_finished = true if channel_name == FINISHED
+          super
+        end
+      end
+    end
+  end
+end

data/lib/test-unit-ext/backtrace-filter.rb

@@ -0,0 +1,17 @@
+require 'test/unit/util/backtracefilter'
+
+module Test
+  module Unit
+    module Util
+      module BacktraceFilter
+        TEST_UNIT_EXT_PREFIX = File.dirname(__FILE__)
+
+        alias_method :original_filter_backtrace, :filter_backtrace
+        def filter_backtrace(backtrace, prefix=nil)
+          original_result = original_filter_backtrace(backtrace, prefix)
+          original_filter_backtrace(original_result, TEST_UNIT_EXT_PREFIX)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module Test
+  class Color
+    NAMES = ["black", "red", "green", "yellow",
+             "blue", "magenta", "cyan", "white"]
+    def initialize(name, options={})
+      @name = name
+      @foreground = options[:foreground]
+      @foreground = true if @foreground.nil?
+      @intensity = options[:intensity]
+      @bold = options[:bold]
+      @italic = options[:italic]
+      @underline = options[:underline]
+    end
+
+    def sequence
+      sequence = []
+      if @name == "none"
+      elsif @name == "reset"
+        sequence << "0"
+      else
+        foreground_parameter = @foreground ? 3 : 4
+        foreground_parameter += 6 if @intensity
+        sequence << "#{foreground_parameter}#{NAMES.index(@name)}"
+      end
+      sequence << "1" if @bold
+      sequence << "3" if @italic
+      sequence << "4" if @underline
+      sequence
+    end
+
+    def escape_sequence
+      "\e[#{sequence.join(';')}m"
+    end
+
+    def +(other)
+      MixColor.new([self, other])
+    end
+  end
+
+  class MixColor
+    def initialize(colors)
+      @colors = colors
+    end
+
+    def sequence
+      @colors.inject([]) do |result, color|
+        result + color.sequence
+      end
+    end
+
+    def escape_sequence
+      "\e[#{sequence.join(';')}m"
+    end
+
+    def +(other)
+      self.class.new([self, other])
+    end
+  end
+end

data/lib/test-unit-ext/colorized-runner.rb

@@ -0,0 +1,101 @@
+require "test/unit/ui/console/testrunner"
+
+module Test
+  module Unit
+    module UI
+      module Console
+        class ColorizedTestRunner < TestRunner
+          extend TestRunnerUtilities
+
+          SCHEMES = {
+            :default => {
+              "success" => Color.new("green", :bold => true),
+              "failure" => Color.new("red", :bold => true),
+              "error" => Color.new("yellow", :bold => true),
+            },
+          }
+
+          def initialize(suite, output_level=NORMAL, io=STDOUT)
+            super
+            @use_color = guess_color_availability
+            @color_scheme = SCHEMES[:default]
+            @reset_color = Color.new("reset")
+          end
+
+          private
+          def add_fault(fault)
+            @faults << fault
+            output_single_with_color(fault.single_character_display,
+                                     fault_color(fault),
+                                     PROGRESS_ONLY)
+            @already_outputted = true
+          end
+
+          def test_finished(name)
+            unless @already_outputted
+              output_single_with_color(".",
+                                       @color_scheme["success"],
+                                       PROGRESS_ONLY)
+            end
+            nl(VERBOSE)
+            @already_outputted = false
+          end
+
+          def finished(elapsed_time)
+            nl
+            output("Finished in #{elapsed_time} seconds.")
+            @faults.each_with_index do |fault, index|
+              nl
+              output_single("%3d) " % (index + 1))
+              output_with_color(fault.long_display, fault_color(fault))
+            end
+            nl
+            output_with_color(@result.to_s, result_color)
+          end
+
+          def fault_color(fault)
+            @color_scheme[fault.class.name.split(/::/).last.downcase]
+          end
+
+          def result_color
+            if @result.passed?
+              @color_scheme["success"]
+            elsif @result.error_count > 0
+              @color_scheme["error"]
+            elsif @result.failure_count > 0
+              @color_scheme["failure"]
+            end
+          end
+
+          def output_with_color(message, color=nil, level=NORMAL)
+            return unless output?(level)
+            output_single_with_color(message, color, level)
+            @io.puts
+          end
+
+          def output_single_with_color(message, color=nil, level=NORMAL)
+            return unless output?(level)
+            if @use_color and color
+              message = "%s%s%s" % [color.escape_sequence,
+                                    message,
+                                    @reset_color.escape_sequence]
+            end
+            @io.write(message)
+            @io.flush
+          end
+
+          def guess_color_availability
+            term = ENV["TERM"]
+            return true if term and (/term\z/ =~ term or term == "screen")
+            return true if ENV["EMACS"] == "t"
+            false
+          end
+        end
+      end
+    end
+
+    AutoRunner::RUNNERS[:console] = Proc.new do
+      Test::Unit::UI::Console::ColorizedTestRunner
+    end
+  end
+end

data/lib/test-unit-ext/diff.rb

@@ -0,0 +1,187 @@
+# port of ndiff in Python's difflib.
+
+module Test
+  module Diff
+    class SequenceMatcher
+      def initialize(from, to)
+        @from = from
+        @to = to
+        update_to_indexes
+      end
+
+      def longest_match(from_start, from_end, to_start, to_end)
+        best_from, best_to, best_size = from_start, to_start, 0
+        lengths = {}
+        from_start.upto(from_end) do |i|
+          new_lengths = {}
+          (@to_indexes[@from[i]] || []).each do |j|
+            next if j < to_start
+            break if j >= to_end
+            k = new_lengths[j] = (lengths[j - 1] || 0) + 1
+            if k > best_size
+              best_from, best_to, best_size = i - k + 1, j - k + 1, k
+            end
+          end
+          lengths = new_lengths
+        end
+
+        while best_from > from_start and best_to > to_start and
+            @from[best_from - 1] == @to[best_to - 1]
+          best_from -= 1
+          best_to -= 1
+          best_size += 1
+        end
+
+        while best_from + best_size <= from_end and
+            best_to + best_size <= to_end and
+            @from[best_from + best_size] == @to[best_to + best_size]
+          best_size += 1
+        end
+
+        [best_from, best_to, best_size]
+      end
+
+      def matching_blocks
+        queue = [[0, @from.size - 1, 0, @to.size - 1]]
+        blocks = []
+        until queue.empty?
+          from_start, from_end, to_start, to_end = queue.pop
+          match_info = longest_match(from_start, from_end, to_start, to_end)
+          match_from_index, match_to_index, size = match_info
+          unless size.zero?
+            blocks << match_info
+            if from_start < match_from_index and to_start < match_to_index
+              queue.push([from_start, match_from_index,
+                          to_start, match_to_index])
+            end
+            if match_from_index + size < from_end and
+                match_to_index + size < to_end
+              queue.push([match_from_index + size, from_end,
+                          match_to_index + size, to_end])
+            end
+          end
+        end
+
+        non_adjacent = []
+        prev_from_index = prev_to_index = prev_size = 0
+        blocks.sort.each do |from_index, to_index, size|
+          if prev_from_index + prev_size == from_index and
+              prev_to_index + prev_size == to_index
+            prev_size += size
+          else
+            unless prev_size.zero?
+              non_adjacent << [prev_from_index, prev_to_index, prev_size]
+            end
+            prev_from_index, prev_to_index, prev_size =
+              from_index, to_index, size
+          end
+        end
+        unless prev_size.zero?
+          non_adjacent << [prev_from_index, prev_to_index, prev_size]
+        end
+
+        non_adjacent << [@from.size, @to.size, 0]
+        non_adjacent
+      end
+
+      def operations
+        from_index = to_index = 0
+        operations = []
+        matching_blocks.each do |match_from_index, match_to_index, size|
+          tag = nil
+          if from_index < match_from_index and to_index < match_to_index
+            tag = :replace
+          elsif from_index < match_from_index
+            tag = :delete
+          elsif to_index < match_to_index
+            tag = :insert
+          end
+
+          if tag
+            operations << [tag,
+                           from_index, match_from_index,
+                           to_index, match_to_index]
+          end
+
+          from_index, to_index = match_from_index + size, match_to_index + size
+          if size > 0
+            operations << [:equal,
+                           match_from_index, from_index,
+                           match_to_index, to_index]
+          end
+        end
+
+        operations
+      end
+
+      private
+      def update_to_indexes
+        @to_indexes = {}
+        @to.each_with_index do |line, i|
+          @to_indexes[line] ||= []
+          @to_indexes[line] << i
+        end
+      end
+    end
+
+    class Differ
+      def initialize(from, to)
+        @from = from
+        @to = to
+      end
+
+      def compare
+        result = []
+        matcher = SequenceMatcher.new(@from, @to)
+        matcher.operations.each do |args|
+          tag, from_start, from_end, to_start, to_end = args
+          case tag
+          when :replace
+            result.concat(fancy_replace(from_start, from_end, to_start, to_end))
+          when :delete
+            result.concat(tagging('-', @from[from_start..from_end]))
+          when :insert
+            result.concat(tagging('+', @to[to_start..to_end]))
+          when :equal
+            result.concat(tagging(' ', @from[from_start..from_end]))
+          else
+            raise "unknown tag: #{tag}"
+          end
+        end
+        result
+      end
+
+      private
+      def tagging(tag, contents)
+        contents.collect {|content| "#{tag} #{content}"}
+      end
+
+      def format_diff_point(from_line, to_line, from_tags, to_tags)
+        common = [n_leading_characters(from_line, ?\t),
+                  n_leading_characters(to_line, ?\t)].min
+        common = [common, n_leading_characters(from_tags[0, common], " "[0])].min
+        from_tags = from_tags[common..-1].rstrip
+        to_tags = to_tags[common..-1].rstrip
+
+        result = ["- #{from_line}"]
+        result << "? #{"\t" * common}#{from_tags}" unless from_tags.empty?
+        result << "+ #{to_line}"
+        result << "? #{"\t" * common}#{to_tags}" unless to_tags.empty?
+        result
+      end
+
+      def n_leading_characters(string, character)
+        n = 0
+        while string[n] == character
+          n += 1
+        end
+        n
+      end
+    end
+
+    module_function
+    def ndiff(from, to)
+      Differ.new(from, to).compare.join("\n")
+    end
+  end
+end

data/lib/test-unit-ext/long-display-for-emacs.rb

@@ -0,0 +1,25 @@
+require 'test/unit/failure'
+require 'test/unit/error'
+
+module Test
+  module Unit
+    BACKTRACE_INFO_RE = /.+:\d+:in `.+?'/
+    class Failure
+      alias_method :original_long_display, :long_display
+      def long_display
+        extract_backtraces_re =
+          /^    \[(#{BACKTRACE_INFO_RE}(?:\n     #{BACKTRACE_INFO_RE})+)\]:$/
+        original_long_display.gsub(extract_backtraces_re) do |backtraces|
+          $1.gsub(/^     (#{BACKTRACE_INFO_RE})/, '\1') + ':'
+        end
+      end
+    end
+
+    class Error
+      alias_method :original_long_display, :long_display
+      def long_display
+        original_long_display.gsub(/^    (#{BACKTRACE_INFO_RE})/, '\1')
+      end
+    end
+  end
+end

data/lib/test-unit-ext/metadata.rb

@@ -0,0 +1,111 @@
+require "test/unit"
+
+module Test
+  module Unit
+    class TestCase
+      class << self
+        alias_method :method_added_without_metadata, :method_added
+        def method_added(name)
+          method_added_without_metadata(name)
+          if defined?(@current_metadata)
+            set_metadata(name, @current_metadata)
+            @current_metadata = {}
+          end
+        end
+
+        def metadata(name, value, *tests)
+          @current_metadata ||= {}
+          if tests.empty?
+            @current_metadata[name] = value
+          else
+            tests.each do |test|
+              set_metadata(test, {name => value})
+            end
+          end
+        end
+
+        def bug(value, *tests)
+          metadata(:bug, value, *tests)
+        end
+
+        def set_metadata(test_name, metadata)
+          return if metadata.empty?
+          test_name = normalize_test_name(test_name)
+          @metadata ||= {}
+          @metadata[test_name] ||= {}
+          @metadata[test_name] = @metadata[test_name].merge(metadata)
+        end
+
+        def get_metadata(test_name)
+          test_name = normalize_test_name(test_name)
+          @metadata ||= {}
+          @metadata[test_name]
+        end
+      end
+
+      alias_method :run_without_metadata, :run
+      def run(result, &block)
+        run_without_metadata(TestResultMetadataSupport.new(result, self), &block)
+      end
+
+      def metadata
+        self.class.get_metadata(@method_name) || {}
+      end
+    end
+
+    class TestResultMetadataSupport
+      def initialize(result, test)
+        @result = result
+        @test = test
+      end
+
+      def add_failure(failure)
+        failure.metadata = @test.metadata
+        method_missing(:add_failure, failure)
+      end
+
+      def add_error(error)
+        error.metadata = @test.metadata
+        method_missing(:add_error, error)
+      end
+
+      def method_missing(name, *args, &block)
+        @result.send(name, *args, &block)
+      end
+    end
+
+    module MetadataFormatter
+      private
+      def format_metadata
+        return '' if metadata.empty?
+        metadata.collect do |key, value|
+          "  #{key}: #{value}"
+        end.join("\n") + "\n"
+      end
+    end
+
+    class Failure
+      include MetadataFormatter
+
+      attr_accessor :metadata
+
+      alias_method :long_display_without_metadata, :long_display
+      def long_display
+        long_display_without_metadata.sub(/(^#{Regexp.escape(@test_name)}.*\n)/,
+                                          "\\1#{format_metadata}")
+      end
+    end
+
+    class Error
+      include MetadataFormatter
+
+      attr_accessor :metadata
+
+      alias_method :long_display_without_metadata, :long_display
+      def long_display
+        long_display_without_metadata.sub(/(^#{Regexp.escape(@test_name)}:\n)/,
+                                          "\\1#{format_metadata}")
+      end
+    end
+  end
+end