test-unit 3.1.4 → 3.6.2

data/lib/test/unit/testresult.rb

@@ -38,12 +38,15 @@ module Test
 
       attr_reader :run_count, :pass_count, :assertion_count, :faults
 
+      attr_accessor :stop_tag
+
       # Constructs a new, empty TestResult.
       def initialize
         @run_count, @pass_count, @assertion_count = 0, 0, 0
         @summary_generators = []
         @problem_checkers = []
         @faults = []
+        @stop_tag = nil
         initialize_containers
       end
 
@@ -92,6 +95,10 @@ module Test
         end
       end
 
+      def stop
+        throw @stop_tag
+      end
+
       def to_s
         summary
       end

data/lib/test/unit/testsuite.rb

@@ -77,7 +77,7 @@ module Test
         @tests -= tests
       end
 
-      # Retuns the rolled up number of tests in this suite;
+      # Returns the rolled up number of tests in this suite;
       # i.e. if the suite contains other suites, it counts the
       # tests within those suites, not the suites themselves.
       def size

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

@@ -3,7 +3,7 @@
 # Author:: Nathaniel Talbott.
 # Copyright::
 #   * Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
-#   * Copyright (c) 2008-2013 Kouhei Sutou <kou@clear-code.com>
+#   * Copyright (c) 2008-2023 Sutou Kouhei <kou@clear-code.com>
 # License:: Ruby license.
 
 begin
@@ -36,12 +36,15 @@ module Test
           # STDOUT.
           def initialize(suite, options={})
             super
-            @output_level = @options[:output_level] || NORMAL
+            @output_level = @options[:output_level] || guess_output_level
             @output = @options[:output] || STDOUT
             @use_color = @options[:use_color]
             @use_color = guess_color_availability if @use_color.nil?
             @color_scheme = @options[:color_scheme] || ColorScheme.default
             @reset_color = Color.new("reset")
+            @progress_style = @options[:progress_style] || guess_progress_style
+            @progress_marks = ["|", "/", "-", "\\", "|", "/", "-", "\\"]
+            @progress_mark_index = 0
             @progress_row = 0
             @progress_row_max = @options[:progress_row_max]
             @progress_row_max ||= guess_progress_row_max
@@ -110,12 +113,17 @@ module Test
           end
 
           def finished(elapsed_time)
-            nl if output?(NORMAL) and !output?(VERBOSE)
-            output_faults unless @show_detail_immediately
-            nl(PROGRESS_ONLY)
-            change_output_level(IMPORTANT_FAULTS_ONLY) do
-              output_statistics(elapsed_time)
+            unless @show_detail_immediately
+              nl if output?(NORMAL) and !output?(VERBOSE)
+              output_faults
+            end
+            case @progress_style
+            when :inplace
+              output_single("\r", nil, PROGRESS_ONLY)
+            when :mark
+              nl(PROGRESS_ONLY)
             end
+            output_statistics(elapsed_time)
           end
 
           def output_faults
@@ -178,21 +186,16 @@ module Test
 
           def output_fault_in_detail(fault)
             if fault.is_a?(Failure) and
-                fault.inspected_expected and fault.inspected_actual
+                fault.inspected_expected and
+                fault.inspected_actual
               output_single("#{fault.label}: ")
               output(fault.test_name, fault_color(fault))
               output_fault_backtrace(fault)
               output_failure_message(fault)
             else
-              if fault.is_a?(Error)
-                output_single("#{fault.label}: ")
-                output_single(fault.test_name, fault_color(fault))
-                output_fault_message(fault)
-              else
-                output_single(fault.label, fault_color(fault))
-                output_fault_message(fault)
-                output(fault.test_name)
-              end
+              output_single("#{fault.label}: ")
+              output_single(fault.test_name, fault_color(fault))
+              output_fault_message(fault)
               output_fault_backtrace(fault)
             end
           end
@@ -212,26 +215,38 @@ module Test
           end
 
           def output_fault_backtrace(fault)
-            snippet_is_shown = false
             detector = FaultLocationDetector.new(fault, @code_snippet_fetcher)
             backtrace = fault.location
             # workaround for test-spec. :<
             # see also GitHub:#22
             backtrace ||= []
+
+            code_snippet_backtrace_index = nil
+            code_snippet_lines = nil
             backtrace.each_with_index do |entry, i|
-              output(entry)
-              next if snippet_is_shown
               next unless detector.target?(entry)
               file, line_number, = detector.split_backtrace_entry(entry)
-              snippet_is_shown = output_code_snippet(file, line_number,
-                                                     fault_color(fault))
+              lines = fetch_code_snippet(file, line_number)
+              unless lines.empty?
+                code_snippet_backtrace_index = i
+                code_snippet_lines = lines
+                break
+              end
+            end
+
+            backtrace.each_with_index do |entry, i|
+              output(entry)
+              if i == code_snippet_backtrace_index
+                output_code_snippet(code_snippet_lines, fault_color(fault))
+              end
             end
           end
 
-          def output_code_snippet(file, line_number, target_line_color=nil)
-            lines = @code_snippet_fetcher.fetch(file, line_number)
-            return false if lines.empty?
+          def fetch_code_snippet(file, line_number)
+            @code_snippet_fetcher.fetch(file, line_number)
+          end
 
+          def output_code_snippet(lines, target_line_color=nil)
             max_n = lines.collect {|n, line, attributes| n}.max
             digits = (Math.log10(max_n) + 1).truncate
             lines.each do |n, line, attributes|
@@ -245,7 +260,6 @@ module Test
               output("  %2s %*d: %s" % [current_line_mark, digits, n, line],
                      line_color)
             end
-            true
           end
 
           def output_failure_message(failure)
@@ -303,6 +317,7 @@ module Test
           end
 
           def output_fault_in_short(fault)
+            output_single("#{fault.label}: ")
             output_single(fault.message, fault_color(fault))
             output(" [#{fault.test_name}]")
             output(fault.location.first)
@@ -313,9 +328,13 @@ module Test
           end
 
           def output_statistics(elapsed_time)
-            output("Finished in #{elapsed_time} seconds.")
+            change_output_level(IMPORTANT_FAULTS_ONLY) do
+              output("Finished in #{elapsed_time} seconds.")
+            end
             output_summary_marker
-            output(@result)
+            change_output_level(IMPORTANT_FAULTS_ONLY) do
+              output(@result)
+            end
             output("%g%% passed" % @result.pass_percentage)
             unless elapsed_time.zero?
               output_summary_marker
@@ -330,30 +349,45 @@ module Test
           end
 
           def output_summary_marker
-            term_width = guess_term_width
-            if term_width.zero?
-              marker_width = 6
-            else
-              marker_width = term_width
-            end
-            output("-" * marker_width, summary_marker_color)
+            return if @progress_row_max <= 0
+            output("-" * @progress_row_max, summary_marker_color)
           end
 
           def test_started(test)
             return unless output?(VERBOSE)
 
-            name = test.name.sub(/\(.+?\)\z/, '')
-            right_space = 8 * 2
+            tab_width = 8
+            name = test.local_name
+            separator = ":"
+            left_used = indent.size + name.size + separator.size
+            right_space = tab_width * 2
             left_space = @progress_row_max - right_space
-            left_space = left_space - indent.size - name.size
-            tab_stop = "\t" * ([left_space - 1, 0].max / 8)
-            output_single("#{indent}#{name}:#{tab_stop}", nil, VERBOSE)
+            if (left_used % tab_width).zero?
+              left_space -= left_used
+              n_tabs = 0
+            else
+              left_space -= ((left_used / tab_width) + 1) * tab_width
+              n_tabs = 1
+            end
+            n_tabs += [left_space, 0].max / tab_width
+            tab_stop = "\t" * n_tabs
+            output_single("#{indent}#{name}#{separator}#{tab_stop}",
+                          nil,
+                          VERBOSE)
             @test_start = Time.now
           end
 
           def test_finished(test)
             unless @already_outputted
-              output_progress(".", color("pass-marker"))
+              case @progress_style
+              when :inplace
+                mark = @progress_marks[@progress_mark_index]
+                @progress_mark_index =
+                  (@progress_mark_index + 1) % @progress_marks.size
+                output_progress(mark, color("pass-marker"))
+              when :mark
+                output_progress(".", color("pass-marker"))
+              end
             end
             @already_outputted = false
 
@@ -416,18 +450,24 @@ module Test
 
           def output_single(something, color=nil, level=nil)
             return false unless output?(level)
-            if @use_color and color
-              something = "%s%s%s" % [color.escape_sequence,
-                                      something,
-                                      @reset_color.escape_sequence]
+            something.to_s.each_line do |line|
+              if @use_color and color
+                line = "%s%s%s" % [color.escape_sequence,
+                                   line,
+                                   @reset_color.escape_sequence]
+              end
+              @output.write(line)
             end
-            @output.write(something)
             @output.flush
             true
           end
 
           def output_progress(mark, color=nil)
-            if output_single(mark, color, PROGRESS_ONLY)
+            if @progress_style == :inplace
+              output_single("\r#{mark}", color, PROGRESS_ONLY)
+            else
+              return unless output?(PROGRESS_ONLY)
+              output_single(mark, color)
               return unless @progress_row_max > 0
               @progress_row += mark.size
               if @progress_row >= @progress_row_max
@@ -438,24 +478,29 @@ module Test
           end
 
           def output_progress_in_detail_marker(fault)
-            if @progress_row_max > 0
-              output("=" * @progress_row_max)
-            else
-              nl
-            end
+            return if @progress_row_max <= 0
+            output("=" * @progress_row_max)
           end
 
           def output_progress_in_detail(fault)
             return if @output_level == SILENT
-            nl
-            output_progress_in_detail_marker(fault)
-            if categorize_fault(fault) == :need_detail_faults
-              output_fault_in_detail(fault)
+            need_detail_faults = (categorize_fault(fault) == :need_detail_faults)
+            if need_detail_faults
+              log_level = IMPORTANT_FAULTS_ONLY
             else
-              output_fault_in_short(fault)
+              log_level = @current_output_level
+            end
+            change_output_level(log_level) do
+              nl(NORMAL)
+              output_progress_in_detail_marker(fault)
+              if need_detail_faults
+                output_fault_in_detail(fault)
+              else
+                output_fault_in_short(fault)
+              end
+              output_progress_in_detail_marker(fault)
+              @progress_row = 0
             end
-            output_progress_in_detail_marker(fault)
-            @progress_row = 0
           end
 
           def output?(level)
@@ -473,8 +518,12 @@ module Test
             fault_class.name.split(/::/).last.downcase
           end
 
+          def fault_class_color(fault_class)
+            color(fault_class_color_name(fault_class))
+          end
+
           def fault_color(fault)
-            color(fault_class_color_name(fault.class))
+            fault_class_color(fault.class)
           end
 
           def fault_marker_color(fault)
@@ -485,18 +534,54 @@ module Test
             color("#{@result.status}-marker")
           end
 
+          def guess_output_level
+            if ENV["GITHUB_ACTIONS"] == "true"
+              IMPORTANT_FAULTS_ONLY
+            else
+              NORMAL
+            end
+          end
+
+          TERM_COLOR_SUPPORT = /
+            color|  # explicitly claims color support in the name
+            direct| # explicitly claims "direct color" (24 bit) support
+            #{ColorScheme::TERM_256}|
+            \Acygwin|
+            \Alinux|
+            \Ansterm-bce|
+            \Ansterm-c-|
+            \Aputty|
+            \Arxvt|
+            \Ascreen|
+            \Atmux|
+            \Axterm
+          /x
+
           def guess_color_availability
+            return true if ENV["GITHUB_ACTIONS"] == "true"
             return false unless @output.tty?
             return true if windows? and ruby_2_0_or_later?
             case ENV["TERM"]
             when /(?:term|screen)(?:-(?:256)?color)?\z/
               true
+            when TERM_COLOR_SUPPORT
+              true
             else
               return true if ENV["EMACS"] == "t"
               false
             end
           end
 
+          def guess_progress_style
+            if @output_level >= VERBOSE
+              :mark
+            else
+              return :fault_only if ENV["GITHUB_ACTIONS"] == "true"
+              return :fault_only unless @output.tty?
+              :inplace
+            end
+          end
+
           def windows?
             /mswin|mingw/ === RUBY_PLATFORM
           end
@@ -620,6 +705,7 @@ module Test
 
           def diff_line(from_line, to_line)
             to_operations = []
+            mark_operations = []
             from_line, to_line, _operations = line_operations(from_line, to_line)
 
             no_replace = true
@@ -649,11 +735,22 @@ module Test
                     output_single(" " * (from_width - to_width))
                   end
                 end
+                mark_operations << Proc.new do
+                  output_single("?" * from_width,
+                                color("diff-difference-tag"))
+                  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)}
+                  mark_operations << Proc.new do
+                    output_single("-" * from_width,
+                                  color("diff-deleted"))
+                  end
                 end
               when :insert
                 if no_replace
@@ -665,11 +762,16 @@ module Test
                     output_single(to_line[to_start...to_end],
                                   color("diff-inserted"))
                   end
+                  mark_operations << Proc.new do
+                    output_single("+" * to_width,
+                                  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)}
+                  mark_operations << Proc.new {output_single(" " * to_width)}
                 end
               else
                 raise "unknown tag: #{tag}"
@@ -685,6 +787,15 @@ module Test
               end
               output("")
             end
+
+            unless mark_operations.empty?
+              output_single("?", color("diff-difference-tag"))
+              output_single(" ")
+              mark_operations.each do |operation|
+                operation.call
+              end
+              output("")
+            end
           end
         end
       end

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

@@ -30,16 +30,16 @@ module Test
               location_display = "\n" + failure.location.join("\n")
             end
             result = "#{failure.label}:\n"
-            result << "#{failure.test_name}#{location_display}:\n"
-            result << failure.message
+            result += "#{failure.test_name}#{location_display}:\n"
+            result += failure.message
             result
           end
 
           def format_fault_error(error)
             result = "#{error.label}:\n"
-            result << "#{error.test_name}:\n"
-            result << "#{error.message}\n"
-            result << error.backtrace.join("\n")
+            result += "#{error.test_name}:\n"
+            result += "#{error.message}\n"
+            result += error.backtrace.join("\n")
             result
           end
         end

data/lib/test/unit/ui/testrunnermediator.rb

@@ -4,7 +4,6 @@
 # Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
 # License:: Ruby license.
 
-require 'test/unit'
 require 'test/unit/util/observable'
 require 'test/unit/testresult'
 
@@ -18,9 +17,9 @@ module Test
         RESET = name + "::RESET"
         STARTED = name + "::STARTED"
         FINISHED = name + "::FINISHED"
-        
+
         include Util::Observable
-        
+
         # Creates a new TestRunnerMediator initialized to run
         # the passed suite.
         def initialize(suite)
@@ -37,11 +36,14 @@ module Test
           Test::Unit.run_at_start_hooks
           start_time = Time.now
           begin
-            with_listener(result) do
-              notify_listeners(RESET, @suite.size)
-              notify_listeners(STARTED, result)
+            catch do |stop_tag|
+              result.stop_tag = stop_tag
+              with_listener(result) do
+                notify_listeners(RESET, @suite.size)
+                notify_listeners(STARTED, result)
 
-              run_suite(result)
+                run_suite(result)
+              end
             end
           ensure
             elapsed_time = Time.now - start_time

data/lib/test/unit/util/backtracefilter.rb

@@ -1,3 +1,8 @@
+begin
+  require 'power_assert'
+rescue LoadError, SyntaxError
+end
+
 module Test
   module Unit
     module Util
@@ -6,21 +11,28 @@ module Test
         TESTUNIT_PREFIX = __FILE__.split(TESTUNIT_FILE_SEPARATORS)[0..-3]
         TESTUNIT_RB_FILE = /\.rb\Z/
 
+        POWERASSERT_PREFIX =
+          defined?(::PowerAssert) ?
+            ::PowerAssert.method(:start).source_location[0].split(TESTUNIT_FILE_SEPARATORS)[0..-2] :
+            nil
+
         module_function
         def filter_backtrace(backtrace, prefix=nil)
           return ["No backtrace"] unless backtrace
           return backtrace if ENV["TEST_UNIT_ALL_BACKTRACE"]
 
           if prefix
-            split_prefix = prefix.split(TESTUNIT_FILE_SEPARATORS)
+            split_prefixes = [prefix.split(TESTUNIT_FILE_SEPARATORS)]
           else
-            split_prefix = TESTUNIT_PREFIX
+            split_prefixes = [TESTUNIT_PREFIX, POWERASSERT_PREFIX].compact
           end
           test_unit_internal_p = lambda do |entry|
             components = entry.split(TESTUNIT_FILE_SEPARATORS)
-            split_entry = components[0, split_prefix.size]
-            next false unless split_entry[0..-2] == split_prefix[0..-2]
-            split_entry[-1].sub(TESTUNIT_RB_FILE, '') == split_prefix[-1]
+            split_prefixes.any? do |split_prefix|
+              split_entry = components[0, split_prefix.size]
+              next false unless split_entry[0..-2] == split_prefix[0..-2]
+              split_entry[-1].sub(TESTUNIT_RB_FILE, '') == split_prefix[-1]
+            end
           end
 
           in_user_code = false

data/lib/test/unit/util/memory-usage.rb

@@ -0,0 +1,47 @@
+module Test
+  module Unit
+    module Util
+      class MemoryUsage
+        attr_reader :virtual
+        attr_reader :physical
+        def initialize
+          @virtual = nil
+          @physical = nil
+          collect_data
+        end
+
+        def collected?
+          return false if @virtual.nil?
+          return false if @physical.nil?
+          true
+        end
+
+        private
+        def collect_data
+          collect_data_proc
+        end
+
+        def collect_data_proc
+          status_file = "/proc/self/status"
+          return false unless File.exist?(status_file)
+
+          data = File.binread(status_file)
+          data.each_line do |line|
+            case line
+            when /\AVm(Size|RSS):\s*(\d+)\s*kB/
+              name = $1
+              value = Integer($2, 10) * 1024
+              case name
+              when "Size"
+                @virtual = value
+              when "RSS"
+                @physical = value
+              end
+            end
+          end
+          collected?
+        end
+      end
+    end
+  end
+end

data/lib/test/unit/util/observable.rb

@@ -26,8 +26,8 @@ module Test
         # returned, making it very easy to use the proc
         # itself as the listener_key:
         #
-        #  listener = add_listener("Channel") { ... }
-        #  remove_listener("Channel", listener)
+        #     listener = add_listener("Channel") { ... }
+        #     remove_listener("Channel", listener)
         def add_listener(channel_name, listener_key=NOTHING, &listener) # :yields: value
           unless(block_given?)
             raise ArgumentError.new("No callback was passed as a listener")

data/lib/test/unit/util/output.rb

@@ -7,10 +7,11 @@ module Test
         # error as string.
         #
         # Example:
-        #   capture_output do
-        #     puts("stdout")
-        #     warn("stderr")
-        #   end # -> ["stdout\n", "stderr\n"]
+        #
+        #     capture_output do
+        #       puts("stdout")
+        #       warn("stderr")
+        #     end # -> ["stdout\n", "stderr\n"]
         def capture_output
           require 'stringio'
 

data/lib/test/unit/util/procwrapper.rb

@@ -31,10 +31,10 @@ module Test
 
         def ==(other)
           case(other)
-            when ProcWrapper
-              return @a_proc == other.to_proc
-            else
-              return super
+          when ProcWrapper
+            return @a_proc == other.to_proc
+          else
+            return super
           end
         end
         alias :eql? :==

data/lib/test/unit/version.rb

@@ -1,5 +1,5 @@
 module Test
   module Unit
-    VERSION = '3.1.4'
+    VERSION = "3.6.2"
   end
 end

data/lib/test/unit/warning.rb

@@ -0,0 +1,3 @@
+if defined?(Warning) and Warning.respond_to?(:[]=)
+  Warning[:deprecated] = true
+end