test-unit-minitest 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6650ecbb2b27cc3923b098b2696c09b5ff8c354b
+  data.tar.gz: dbd05d852ce49a65deeecc3a13afe2e01874428c
+SHA512:
+  metadata.gz: 12dc3d8a7789fa414da3050974857b53b2969663901d8ece1c50472c25ca51ba9bceb0d206b734415499aaff06d1983a88492765d8230a3791110fd50b7531b3
+  data.tar.gz: 98b9b4c9fe1da1bb1e736d7c38313ae8890ed40b4403ec8f7066f6b87ccf1821e7285f08fe776293063bac64c80bf497a339c3816589e77c6330ee95c51bc0e4

data/LICENSE

@@ -0,0 +1,56 @@
+Ruby is copyrighted free software by Yukihiro Matsumoto <matz@netlab.jp>.
+You can redistribute it and/or modify it under either the terms of the
+2-clause BSDL (see the file BSDL), or the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+    modifications to Usenet or an equivalent medium, or by allowing
+    the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) give non-standard binaries non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or binary form,
+     provided that you do at least ONE of the following:
+
+       a) distribute the binaries and library files of the software,
+    together with instructions (in the manual page or equivalent)
+    on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+    the software.
+
+       c) give non-standard binaries non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  But some files in the distribution
+     are not written by the author, so that they are not under these terms.
+
+     For the list of those files and their copying conditions, see the
+     file LEGAL.
+
+  5. The scripts and library files supplied as input to or produced as
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them,
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.

data/README.md

@@ -0,0 +1,29 @@
+[![Build Status](http://img.shields.io/travis/iGEL/test-unit-minitest/master.svg?style=flat)](https://travis-ci.org/iGEL/test-unit-minitest)
+# minitest wrapper for Test::Unit
+
+Between Ruby 1.9 and 2.1, Ruby came with a wrapper around minitest to
+provide the same interface of Test::Unit that was available with Ruby
+1.8. Ruby 2.2 comes with bundled gems of Test::Unit, but this is not
+the wrapper. Some tests for the wrapped Test::Unit actually used
+minitest features which are not available in the real thing, for
+example some assertions of Rails 4.0.
+
+This is a copy of the Wrapper from Ruby 2.1 as written by Shota
+Fukumori. The License is same as Ruby's.
+
+**I don't plan to maintain this for a long time. If possible, use
+minitest directly.**
+
+## Usage
+
+If the tests require the correct files from Test::Unit, just drop this
+in your `Gemfile`:
+
+```ruby
+gem 'test-unit-minitest', require: nil
+```
+
+Otherwise this:
+```ruby
+gem 'test-unit-minitest', require: 'test/unit'
+```

data/bin/testrb

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require_relative '../lib/test/unit'
+exit Test::Unit::AutoRunner.run(true)

data/lib/test/unit.rb

@@ -0,0 +1,876 @@
+require 'minitest/unit'
+require 'test/unit/assertions'
+require 'test/unit/testcase'
+require 'optparse'
+
+# See Test::Unit
+module Test
+  ##
+  # Test::Unit is an implementation of the xUnit testing framework for Ruby.
+  #
+  # If you are writing new test code, please use MiniTest instead of Test::Unit.
+  #
+  # Test::Unit has been left in the standard library to support legacy test
+  # suites.
+  module Unit
+    TEST_UNIT_IMPLEMENTATION = 'test/unit compatibility layer using minitest' # :nodoc:
+
+    module RunCount # :nodoc: all
+      @@run_count = 0
+
+      def self.have_run?
+        @@run_count.nonzero?
+      end
+
+      def run(*)
+        @@run_count += 1
+        super
+      end
+
+      def run_once
+        return if have_run?
+        return if $! # don't run if there was an exception
+        yield
+      end
+      module_function :run_once
+    end
+
+    module Options # :nodoc: all
+      def initialize(*, &block)
+        @init_hook = block
+        @options = nil
+        super(&nil)
+      end
+
+      def option_parser
+        @option_parser ||= OptionParser.new
+      end
+
+      def process_args(args = [])
+        return @options if @options
+        orig_args = args.dup
+        options = {}
+        opts = option_parser
+        setup_options(opts, options)
+        opts.parse!(args)
+        orig_args -= args
+        args = @init_hook.call(args, options) if @init_hook
+        non_options(args, options)
+        @help = orig_args.map { |s| s =~ /[\s|&<>$()]/ ? s.inspect : s }.join " "
+        @options = options
+        if @options[:parallel]
+          @files = args
+          @args = orig_args
+        end
+        options
+      end
+
+      private
+      def setup_options(opts, options)
+        opts.separator 'minitest options:'
+        opts.version = MiniTest::Unit::VERSION
+
+        options[:retry] = true
+        options[:job_status] = nil
+
+        opts.on '-h', '--help', 'Display this help.' do
+          puts opts
+          exit
+        end
+
+        opts.on '-s', '--seed SEED', Integer, "Sets random seed" do |m|
+          options[:seed] = m
+        end
+
+        opts.on '-v', '--verbose', "Verbose. Show progress processing files." do
+          options[:verbose] = true
+          self.verbose = options[:verbose]
+        end
+
+        opts.on '-n', '--name PATTERN', "Filter test names on pattern." do |a|
+          options[:filter] = a
+        end
+
+        opts.on '--jobs-status [TYPE]', [:normal, :replace],
+                "Show status of jobs every file; Disabled when --jobs isn't specified." do |type|
+          options[:job_status] = type || :normal
+        end
+
+        opts.on '-j N', '--jobs N', "Allow run tests with N jobs at once" do |a|
+          if /^t/ =~ a
+            options[:testing] = true # For testing
+            options[:parallel] = a[1..-1].to_i
+          else
+            options[:parallel] = a.to_i
+          end
+        end
+
+        opts.on '--separate', "Restart job process after one testcase has done" do
+          options[:parallel] ||= 1
+          options[:separate] = true
+        end
+
+        opts.on '--retry', "Retry running testcase when --jobs specified" do
+          options[:retry] = true
+        end
+
+        opts.on '--no-retry', "Disable --retry" do
+          options[:retry] = false
+        end
+
+        opts.on '--ruby VAL', "Path to ruby; It'll have used at -j option" do |a|
+          options[:ruby] = a.split(/ /).reject(&:empty?)
+        end
+
+        opts.on '-q', '--hide-skip', 'Hide skipped tests' do
+          options[:hide_skip] = true
+        end
+
+        opts.on '--show-skip', 'Show skipped tests' do
+          options[:hide_skip] = false
+        end
+
+        opts.on '--color[=WHEN]',
+                [:always, :never, :auto],
+                "colorize the output.  WHEN defaults to 'always'", "or can be 'never' or 'auto'." do |c|
+          options[:color] = c || :always
+        end
+
+        opts.on '--tty[=WHEN]',
+                [:yes, :no],
+                "force to output tty control.  WHEN defaults to 'yes'", "or can be 'no'." do |c|
+          @tty = c != :no
+        end
+      end
+
+      def non_options(files, options)
+        begin
+          require "rbconfig"
+        rescue LoadError
+          warn "#{caller(1)[0]}: warning: Parallel running disabled because can't get path to ruby; run specify with --ruby argument"
+          options[:parallel] = nil
+        else
+          options[:ruby] ||= [RbConfig.ruby]
+        end
+
+        true
+      end
+    end
+
+    module GlobOption # :nodoc: all
+      @@testfile_prefix = "test"
+
+      def setup_options(parser, options)
+        super
+        parser.on '-b', '--basedir=DIR', 'Base directory of test suites.' do |dir|
+          options[:base_directory] = dir
+        end
+        parser.on '-x', '--exclude PATTERN', 'Exclude test files on pattern.' do |pattern|
+          (options[:reject] ||= []) << pattern
+        end
+      end
+
+      def non_options(files, options)
+        paths = [options.delete(:base_directory), nil].uniq
+        if reject = options.delete(:reject)
+          reject_pat = Regexp.union(reject.map {|r| /#{r}/ })
+        end
+        files.map! {|f|
+          f = f.tr(File::ALT_SEPARATOR, File::SEPARATOR) if File::ALT_SEPARATOR
+          ((paths if /\A\.\.?(?:\z|\/)/ !~ f) || [nil]).any? do |prefix|
+            if prefix
+              path = f.empty? ? prefix : "#{prefix}/#{f}"
+            else
+              next if f.empty?
+              path = f
+            end
+            if !(match = Dir["#{path}/**/#{@@testfile_prefix}_*.rb"]).empty?
+              if reject
+                match.reject! {|n|
+                  n[(prefix.length+1)..-1] if prefix
+                  reject_pat =~ n
+                }
+              end
+              break match
+            elsif !reject or reject_pat !~ f and File.exist? path
+              break path
+            end
+          end or
+            raise ArgumentError, "file not found: #{f}"
+        }
+        files.flatten!
+        super(files, options)
+      end
+    end
+
+    module LoadPathOption # :nodoc: all
+      def setup_options(parser, options)
+        super
+        parser.on '-Idirectory', 'Add library load path' do |dirs|
+          dirs.split(':').each { |d| $LOAD_PATH.unshift d }
+        end
+      end
+    end
+
+    module GCStressOption # :nodoc: all
+      def setup_options(parser, options)
+        super
+        parser.on '--[no-]gc-stress', 'Set GC.stress as true' do |flag|
+          options[:gc_stress] = flag
+        end
+      end
+
+      def non_options(files, options)
+        if options.delete(:gc_stress)
+          MiniTest::Unit::TestCase.class_eval do
+            oldrun = instance_method(:run)
+            define_method(:run) do |runner|
+              begin
+                gc_stress, GC.stress = GC.stress, true
+                oldrun.bind(self).call(runner)
+              ensure
+                GC.stress = gc_stress
+              end
+            end
+          end
+        end
+        super
+      end
+    end
+
+    module RequireFiles # :nodoc: all
+      def non_options(files, options)
+        return false if !super
+        result = false
+        files.each {|f|
+          d = File.dirname(path = File.realpath(f))
+          unless $:.include? d
+            $: << d
+          end
+          begin
+            require path unless options[:parallel]
+            result = true
+          rescue LoadError
+            puts "#{f}: #{$!}"
+          end
+        }
+        result
+      end
+    end
+
+    class Runner < MiniTest::Unit # :nodoc: all
+      include Test::Unit::Options
+      include Test::Unit::GlobOption
+      include Test::Unit::LoadPathOption
+      include Test::Unit::GCStressOption
+      include Test::Unit::RunCount
+
+      class Worker
+        def self.launch(ruby,args=[])
+          io = IO.popen([*ruby,
+                        "#{File.dirname(__FILE__)}/unit/parallel.rb",
+                        *args], "rb+")
+          new(io, io.pid, :waiting)
+        end
+
+        attr_reader :quit_called
+
+        def initialize(io, pid, status)
+          @io = io
+          @pid = pid
+          @status = status
+          @file = nil
+          @real_file = nil
+          @loadpath = []
+          @hooks = {}
+          @quit_called = false
+        end
+
+        def puts(*args)
+          @io.puts(*args)
+        end
+
+        def run(task,type)
+          @file = File.basename(task, ".rb")
+          @real_file = task
+          begin
+            puts "loadpath #{[Marshal.dump($:-@loadpath)].pack("m0")}"
+            @loadpath = $:.dup
+            puts "run #{task} #{type}"
+            @status = :prepare
+          rescue Errno::EPIPE
+            died
+          rescue IOError
+            raise unless ["stream closed","closed stream"].include? $!.message
+            died
+          end
+        end
+
+        def hook(id,&block)
+          @hooks[id] ||= []
+          @hooks[id] << block
+          self
+        end
+
+        def read
+          res = (@status == :quit) ? @io.read : @io.gets
+          res && res.chomp
+        end
+
+        def close
+          @io.close unless @io.closed?
+          self
+        rescue IOError
+        end
+
+        def quit
+          return if @io.closed?
+          @quit_called = true
+          @io.puts "quit"
+          @io.close
+        end
+
+        def kill
+          Process.kill(:KILL, @pid)
+        rescue Errno::ESRCH
+        end
+
+        def died(*additional)
+          @status = :quit
+          @io.close
+
+          call_hook(:dead,*additional)
+        end
+
+        def to_s
+          if @file
+            "#{@pid}=#{@file}"
+          else
+            "#{@pid}:#{@status.to_s.ljust(7)}"
+          end
+        end
+
+        attr_reader :io, :pid
+        attr_accessor :status, :file, :real_file, :loadpath
+
+        private
+
+        def call_hook(id,*additional)
+          @hooks[id] ||= []
+          @hooks[id].each{|hook| hook[self,additional] }
+          self
+        end
+
+      end
+
+      class << self; undef autorun; end
+
+      @@stop_auto_run = false
+      def self.autorun
+        at_exit {
+          Test::Unit::RunCount.run_once {
+            exit(Test::Unit::Runner.new.run(ARGV) || true)
+          } unless @@stop_auto_run
+        } unless @@installed_at_exit
+        @@installed_at_exit = true
+      end
+
+      def after_worker_down(worker, e=nil, c=false)
+        return unless @options[:parallel]
+        return if @interrupt
+        warn e if e
+        @need_quit = true
+        warn ""
+        warn "Some worker was crashed. It seems ruby interpreter's bug"
+        warn "or, a bug of test/unit/parallel.rb. try again without -j"
+        warn "option."
+        warn ""
+        STDERR.flush
+        exit c
+      end
+
+      def terminal_width
+        unless @terminal_width ||= nil
+          begin
+            require 'io/console'
+            width = $stdout.winsize[1]
+          rescue LoadError, NoMethodError, Errno::ENOTTY, Errno::EBADF
+            width = ENV["COLUMNS"].to_i.nonzero? || 80
+          end
+          width -= 1 if /mswin|mingw/ =~ RUBY_PLATFORM
+          @terminal_width = width
+        end
+        @terminal_width
+      end
+
+      def del_status_line
+        @status_line_size ||= 0
+        unless @options[:job_status] == :replace
+          $stdout.puts
+          return
+        end
+        print "\r"+" "*@status_line_size+"\r"
+        $stdout.flush
+        @status_line_size = 0
+      end
+
+      def put_status(line)
+        unless @options[:job_status] == :replace
+          print(line)
+          return
+        end
+        @status_line_size ||= 0
+        del_status_line
+        $stdout.flush
+        line = line[0...terminal_width]
+        print line
+        $stdout.flush
+        @status_line_size = line.size
+      end
+
+      def add_status(line)
+        unless @options[:job_status] == :replace
+          print(line)
+          return
+        end
+        @status_line_size ||= 0
+        line = line[0...(terminal_width-@status_line_size)]
+        print line
+        $stdout.flush
+        @status_line_size += line.size
+      end
+
+      def jobs_status
+        return unless @options[:job_status]
+        puts "" unless @options[:verbose] or @options[:job_status] == :replace
+        status_line = @workers.map(&:to_s).join(" ")
+        update_status(status_line) or (puts; nil)
+      end
+
+      def del_jobs_status
+        return unless @options[:job_status] == :replace && @status_line_size.nonzero?
+        del_status_line
+      end
+
+      def after_worker_quit(worker)
+        return unless @options[:parallel]
+        return if @interrupt
+        @workers.delete(worker)
+        @dead_workers << worker
+        @ios = @workers.map(&:io)
+      end
+
+      def launch_worker
+        begin
+          worker = Worker.launch(@options[:ruby],@args)
+        rescue => e
+          abort "ERROR: Failed to launch job process - #{e.class}: #{e.message}"
+        end
+        worker.hook(:dead) do |w,info|
+          after_worker_quit w
+          after_worker_down w, *info if !info.empty? && !worker.quit_called
+        end
+        @workers << worker
+        @ios << worker.io
+        @workers_hash[worker.io] = worker
+        worker
+      end
+
+      def delete_worker(worker)
+        @workers_hash.delete worker.io
+        @workers.delete worker
+        @ios.delete worker.io
+      end
+
+      def quit_workers
+        return if @workers.empty?
+        @workers.reject! do |worker|
+          begin
+            timeout(1) do
+              worker.quit
+            end
+          rescue Errno::EPIPE
+          rescue Timeout::Error
+          end
+          worker.close
+        end
+
+        return if @workers.empty?
+        begin
+          timeout(0.2 * @workers.size) do
+            Process.waitall
+          end
+        rescue Timeout::Error
+          @workers.each do |worker|
+            worker.kill
+          end
+          @worker.clear
+        end
+      end
+
+      def start_watchdog
+        Thread.new do
+          while stat = Process.wait2
+            break if @interrupt # Break when interrupt
+            pid, stat = stat
+            w = (@workers + @dead_workers).find{|x| pid == x.pid }
+            next unless w
+            w = w.dup
+            if w.status != :quit && !w.quit_called?
+              # Worker down
+              w.died(nil, !stat.signaled? && stat.exitstatus)
+            end
+          end
+        end
+      end
+
+      def deal(io, type, result, rep, shutting_down = false)
+        worker = @workers_hash[io]
+        case worker.read
+        when /^okay$/
+          worker.status = :running
+          jobs_status
+        when /^ready(!)?$/
+          bang = $1
+          worker.status = :ready
+
+          return nil unless task = @tasks.shift
+          if @options[:separate] and not bang
+            worker.quit
+            worker = add_worker
+          end
+          worker.run(task, type)
+          @test_count += 1
+
+          jobs_status
+        when /^done (.+?)$/
+          r = Marshal.load($1.unpack("m")[0])
+          result << r[0..1] unless r[0..1] == [nil,nil]
+          rep    << {file: worker.real_file, report: r[2], result: r[3], testcase: r[5]}
+          $:.push(*r[4]).uniq!
+          return true
+        when /^p (.+?)$/
+          del_jobs_status
+          print $1.unpack("m")[0]
+          jobs_status if @options[:job_status] == :replace
+        when /^after (.+?)$/
+          @warnings << Marshal.load($1.unpack("m")[0])
+        when /^bye (.+?)$/
+          after_worker_down worker, Marshal.load($1.unpack("m")[0])
+        when /^bye$/, nil
+          if shutting_down || worker.quit_called
+            after_worker_quit worker
+          else
+            after_worker_down worker
+          end
+        end
+        return false
+      end
+
+      def _run_parallel suites, type, result
+        if @options[:parallel] < 1
+          warn "Error: parameter of -j option should be greater than 0."
+          return
+        end
+
+        # Require needed things for parallel running
+        require 'thread'
+        require 'timeout'
+        @tasks = @files.dup # Array of filenames.
+        @need_quit = false
+        @dead_workers = []  # Array of dead workers.
+        @warnings = []
+        @total_tests = @tasks.size.to_s(10)
+        rep = [] # FIXME: more good naming
+
+        @workers      = [] # Array of workers.
+        @workers_hash = {} # out-IO => worker
+        @ios          = [] # Array of worker IOs
+        begin
+          # Thread: watchdog
+          watchdog = start_watchdog
+
+          @options[:parallel].times {launch_worker}
+
+          while _io = IO.select(@ios)[0]
+            break if _io.any? do |io|
+              @need_quit or
+                (deal(io, type, result, rep).nil? and
+                 !@workers.any? {|x| [:running, :prepare].include? x.status})
+            end
+          end
+        rescue Interrupt => ex
+          @interrupt = ex
+          return result
+        ensure
+          watchdog.kill if watchdog
+          if @interrupt
+            @ios.select!{|x| @workers_hash[x].status == :running }
+            while !@ios.empty? && (__io = IO.select(@ios,[],[],10))
+              __io[0].reject! {|io| deal(io, type, result, rep, true)}
+            end
+          end
+
+          quit_workers
+
+          unless @interrupt || !@options[:retry] || @need_quit
+            @options[:parallel] = false
+            suites, rep = rep.partition {|r| r[:testcase] && r[:file] && r[:report].any? {|e| !e[2].is_a?(MiniTest::Skip)}}
+            suites.map {|r| r[:file]}.uniq.each {|file| require file}
+            suites.map! {|r| eval("::"+r[:testcase])}
+            del_status_line or puts
+            unless suites.empty?
+              puts "Retrying..."
+              _run_suites(suites, type)
+            end
+          end
+          unless @options[:retry]
+            del_status_line or puts
+          end
+          unless rep.empty?
+            rep.each do |r|
+              r[:report].each do |f|
+                puke(*f) if f
+              end
+            end
+            if @options[:retry]
+              @errors   += rep.map{|x| x[:result][0] }.inject(:+)
+              @failures += rep.map{|x| x[:result][1] }.inject(:+)
+              @skips    += rep.map{|x| x[:result][2] }.inject(:+)
+            end
+          end
+          unless @warnings.empty?
+            warn ""
+            @warnings.uniq! {|w| w[1].message}
+            @warnings.each do |w|
+              warn "#{w[0]}: #{w[1].message} (#{w[1].class})"
+            end
+            warn ""
+          end
+        end
+      end
+
+      def _run_suites suites, type
+        _prepare_run(suites, type)
+        @interrupt = nil
+        result = []
+        GC.start
+        if @options[:parallel]
+          _run_parallel suites, type, result
+        else
+          suites.each {|suite|
+            begin
+              result << _run_suite(suite, type)
+            rescue Interrupt => e
+              @interrupt = e
+              break
+            end
+          }
+        end
+        report.reject!{|r| r.start_with? "Skipped:" } if @options[:hide_skip]
+        report.sort_by!{|r| r.start_with?("Skipped:") ? 0 : \
+                           (r.start_with?("Failure:") ? 1 : 2) }
+        result
+      end
+
+      alias mini_run_suite _run_suite
+
+      def output
+        (@output ||= nil) || super
+      end
+
+      def _prepare_run(suites, type)
+        options[:job_status] ||= :replace if @tty && !@verbose
+        case options[:color]
+        when :always
+          color = true
+        when :auto, nil
+          color = @options[:job_status] == :replace && /dumb/ !~ ENV["TERM"]
+        else
+          color = false
+        end
+        if color
+          # dircolors-like style
+          colors = (colors = ENV['TEST_COLORS']) ? Hash[colors.scan(/(\w+)=([^:]*)/)] : {}
+          @passed_color = "\e[#{colors["pass"] || "32"}m"
+          @failed_color = "\e[#{colors["fail"] || "31"}m"
+          @skipped_color = "\e[#{colors["skip"] || "33"}m"
+          @reset_color = "\e[m"
+        else
+          @passed_color = @failed_color = @skipped_color = @reset_color = ""
+        end
+        if color or @options[:job_status] == :replace
+          @verbose = !options[:parallel]
+          @output = StatusLineOutput.new(self)
+        end
+        if /\A\/(.*)\/\z/ =~ (filter = options[:filter])
+          filter = Regexp.new($1)
+        end
+        type = "#{type}_methods"
+        total = if filter
+                  suites.inject(0) {|n, suite| n + suite.send(type).grep(filter).size}
+                else
+                  suites.inject(0) {|n, suite| n + suite.send(type).size}
+                end
+        @test_count = 0
+        @total_tests = total.to_s(10)
+      end
+
+      def new_test(s)
+        @test_count += 1
+        update_status(s)
+      end
+
+      def update_status(s)
+        count = @test_count.to_s(10).rjust(@total_tests.size)
+        put_status("#{@passed_color}[#{count}/#{@total_tests}]#{@reset_color} #{s}")
+      end
+
+      def _print(s); $stdout.print(s); end
+      def succeed; del_status_line; end
+
+      def failed(s)
+        sep = "\n"
+        @report_count ||= 0
+        report.each do |msg|
+          if msg.start_with? "Skipped:"
+            if @options[:hide_skip]
+              del_status_line
+              next
+            end
+            color = @skipped_color
+          else
+            color = @failed_color
+          end
+          msg = msg.split(/$/, 2)
+          $stdout.printf("%s%s%3d) %s%s%s\n",
+                         sep, color, @report_count += 1,
+                         msg[0], @reset_color, msg[1])
+          sep = nil
+        end
+        report.clear
+      end
+
+      # Overriding of MiniTest::Unit#puke
+      def puke klass, meth, e
+        # TODO:
+        #   this overriding is for minitest feature that skip messages are
+        #   hidden when not verbose (-v), note this is temporally.
+        n = report.size
+        rep = super
+        if MiniTest::Skip === e and /no message given\z/ =~ e.message
+          report.slice!(n..-1)
+          rep = "."
+        end
+        rep
+      end
+
+      def initialize
+        super
+        @tty = $stdout.tty?
+      end
+
+      def status(*args)
+        result = super
+        raise @interrupt if @interrupt
+        result
+      end
+
+      def run(*args)
+        result = super
+        puts "\nruby -v: #{RUBY_DESCRIPTION}"
+        result
+      end
+    end
+
+    class StatusLineOutput < Struct.new(:runner) # :nodoc: all
+      def puts(*a) $stdout.puts(*a) unless a.empty? end
+      def respond_to_missing?(*a) $stdout.respond_to?(*a) end
+      def method_missing(*a, &b) $stdout.__send__(*a, &b) end
+
+      def print(s)
+        case s
+        when /\A(.*\#.*) = \z/
+          runner.new_test($1)
+        when /\A(.* s) = \z/
+          runner.add_status(" = "+$1.chomp)
+        when /\A\.+\z/
+          runner.succeed
+        when /\A[EFS]\z/
+          runner.failed(s)
+        else
+          $stdout.print(s)
+        end
+      end
+    end
+
+    class AutoRunner # :nodoc: all
+      class Runner < Test::Unit::Runner
+        include Test::Unit::RequireFiles
+      end
+
+      attr_accessor :to_run, :options
+
+      def initialize(force_standalone = false, default_dir = nil, argv = ARGV)
+        @force_standalone = force_standalone
+        @runner = Runner.new do |files, options|
+          options[:base_directory] ||= default_dir
+          files << default_dir if files.empty? and default_dir
+          @to_run = files
+          yield self if block_given?
+          files
+        end
+        Runner.runner = @runner
+        @options = @runner.option_parser
+        if @force_standalone
+          @options.banner.sub!(/\[options\]/, '\& tests...')
+        end
+        @argv = argv
+      end
+
+      def process_args(*args)
+        @runner.process_args(*args)
+        !@to_run.empty?
+      end
+
+      def run
+        if @force_standalone and not process_args(@argv)
+          abort @options.banner
+        end
+        @runner.run(@argv) || true
+      end
+
+      def self.run(*args)
+        new(*args).run
+      end
+    end
+
+    class ProxyError < StandardError # :nodoc: all
+      def initialize(ex)
+        @message = ex.message
+        @backtrace = ex.backtrace
+      end
+
+      attr_accessor :message, :backtrace
+    end
+  end
+end
+
+module MiniTest # :nodoc: all
+  class Unit
+  end
+end
+
+class MiniTest::Unit::TestCase # :nodoc: all
+  undef run_test
+  RUN_TEST_TRACE = "#{__FILE__}:#{__LINE__+3}:in `run_test'".freeze
+  def run_test(name)
+    progname, $0 = $0, "#{$0}: #{self.class}##{name}"
+    self.__send__(name)
+  ensure
+    $@.delete(RUN_TEST_TRACE) if $@
+    $0 = progname
+  end
+end
+
+Test::Unit::Runner.autorun