minitest-spec-rails-tu-shim 1.9.3

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/COPYING.txt

@@ -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/LICENSE.txt

@@ -0,0 +1,3 @@
+* Please read COPYING.txt
+* Redistribution of lib/test source directory from Ruby 1.9.3p392.
+  https://github.com/ruby/ruby/tree/v1_9_3_392/lib/test

data/README.md

@@ -0,0 +1,11 @@
+# minitest-spec-rails-tu-shim
+
+Test::Unit compatability for MiniTest For Ruby 1.8 for use with [minitest-spec-rails](https://github.com/metaskills/minitest-spec-rails).
+
+
+## Installation
+
+Add this line to your application's Gemfile if you
+
+    gem 'minitest-spec-rails-tu-shim'
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/test/unit.rb

@@ -0,0 +1,640 @@
+# test/unit compatibility layer using minitest.
+
+require 'minitest/unit'
+require 'test/unit/assertions'
+require 'test/unit/testcase'
+require 'optparse'
+
+module Test
+  module Unit
+    TEST_UNIT_IMPLEMENTATION = 'test/unit compatibility layer using minitest'
+
+    module RunCount
+      @@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
+      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
+
+        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 '--no-retry', "Don't retry running testcase when --jobs specified" do
+          options[:no_retry] = true
+        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
+      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
+      include Options
+
+      @@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
+      include Options
+
+      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
+      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
+      def non_options(files, options)
+        return false if !super
+        result = false
+        files.each {|f|
+          d = File.dirname(path = File.expand_path(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
+      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
+
+        def initialize(io, pid, status)
+          @io = io
+          @pid = pid
+          @status = status
+          @file = nil
+          @real_file = nil
+          @loadpath = []
+          @hooks = {}
+        end
+
+        def puts(*args)
+          @io.puts(*args)
+        end
+
+        def run(task,type)
+          @file = File.basename(task).gsub(/\.rb/,"")
+          @real_file = task
+          begin
+            puts "loadpath #{[Marshal.dump($:-@loadpath)].pack("m").gsub("\n","")}"
+            @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
+          self
+        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
+        if e
+          b = e.backtrace
+          warn "#{b.shift}: #{e.message} (#{e.class})"
+          STDERR.print b.map{|s| "\tfrom #{s}"}.join("\n")
+        end
+        @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 jobs_status
+        return unless @options[:job_status]
+        puts "" unless @options[:verbose]
+        status_line = @workers.map(&:to_s).join(" ")
+        if @options[:job_status] == :replace and $stdout.tty?
+          @terminal_width ||=
+            begin
+              require 'io/console'
+              $stdout.winsize[1]
+            rescue LoadError, NoMethodError
+              ENV["COLUMNS"].to_i.nonzero? || 80
+            end
+          @jstr_size ||= 0
+          del_jobs_status
+          $stdout.flush
+          print status_line[0...@terminal_width]
+          $stdout.flush
+          @jstr_size = [status_line.size, @terminal_width].min
+        else
+          puts status_line
+        end
+      end
+
+      def del_jobs_status
+        return unless @options[:job_status] == :replace && @jstr_size.nonzero?
+        print "\r"+" "*@jstr_size+"\r"
+      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 _run_parallel suites, type, result
+        if @options[:parallel] < 1
+          warn "Error: parameter of -j option should be greater than 0."
+          return
+        end
+
+        begin
+          # 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 = []
+          shutting_down = false
+          rep = [] # FIXME: more good naming
+
+          # Array of workers.
+          @workers = @options[:parallel].times.map {
+            worker = Worker.launch(@options[:ruby],@args)
+            worker.hook(:dead) do |w,info|
+              after_worker_quit w
+              after_worker_down w, *info unless info.empty?
+            end
+            worker
+          }
+
+          # Thread: watchdog
+          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 }.dup
+              next unless w
+              unless w.status == :quit
+                # Worker down
+                w.died(nil, !stat.signaled? && stat.exitstatus)
+              end
+            end
+          end
+
+          @workers_hash = Hash[@workers.map {|w| [w.io,w] }] # out-IO => worker
+          @ios = @workers.map{|w| w.io } # Array of worker IOs
+
+          while _io = IO.select(@ios)[0]
+            break unless _io.each do |io|
+              break if @need_quit
+              worker = @workers_hash[io]
+              case worker.read
+              when /^okay$/
+                worker.status = :running
+                jobs_status
+              when /^ready$/
+                worker.status = :ready
+                if @tasks.empty?
+                  break unless @workers.find{|x| x.status == :running }
+                else
+                  worker.run(@tasks.shift, type)
+                end
+
+                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!
+              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$/
+                if shutting_down
+                  after_worker_quit worker
+                else
+                  after_worker_down worker
+                end
+              end
+              break if @need_quit
+            end
+          end
+        rescue Interrupt => e
+          @interrupt = e
+          return result
+        ensure
+          shutting_down = true
+
+          watchdog.kill if watchdog
+          if @interrupt
+            @ios.select!{|x| @workers_hash[x].status == :running }
+            while !@ios.empty? && (__io = IO.select(@ios,[],[],10))
+                _io = __io[0]
+                _io.each do |io|
+                  worker = @workers_hash[io]
+                  case worker.read
+                  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!
+                    @ios.delete(io)
+                  end
+                end
+            end
+          end
+          @workers.each do |worker|
+            begin
+              timeout(1) do
+                worker.puts "quit"
+              end
+            rescue Errno::EPIPE
+            rescue Timeout::Error
+            end
+            worker.close
+          end
+          begin
+            timeout(0.2*@workers.size) do
+              Process.waitall
+            end
+          rescue Timeout::Error
+            @workers.each do |worker|
+              begin
+                Process.kill(:KILL,worker.pid)
+              rescue Errno::ESRCH; end
+            end
+          end
+
+          if @interrupt || @options[:no_retry] || @need_quit
+            rep.each do |r|
+              report.push(*r[:report])
+            end
+            @errors   += rep.map{|x| x[:result][0] }.inject(:+)
+            @failures += rep.map{|x| x[:result][1] }.inject(:+)
+            @skips    += rep.map{|x| x[:result][2] }.inject(:+)
+          else
+            puts ""
+            puts "Retrying..."
+            puts ""
+            rep.each do |r|
+              if r[:testcase] && r[:file] && !r[:report].empty?
+                require r[:file]
+                _run_suite(eval(r[:testcase]),type)
+              else
+                report.push(*r[:report])
+                @errors += r[:result][0]
+                @failures += r[:result][1]
+                @skips += r[:result][2]
+              end
+            end
+          end
+          if @warnings
+            warn ""
+            ary = []
+            @warnings.reject! do |w|
+              r = ary.include?(w[1].message)
+              ary << w[1].message
+              r
+            end
+            @warnings.each do |w|
+              warn "#{w[0]}: #{w[1].message} (#{w[1].class})"
+            end
+            warn ""
+          end
+        end
+      end
+
+      def _run_suites suites, type
+        @interrupt = nil
+        result = []
+        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]
+        result
+      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.
+        e = case e
+            when MiniTest::Skip then
+              @skips += 1
+              "Skipped:\n#{meth}(#{klass}) [#{location e}]:\n#{e.message}\n"
+            when MiniTest::Assertion then
+              @failures += 1
+              "Failure:\n#{meth}(#{klass}) [#{location e}]:\n#{e.message}\n"
+            else
+              @errors += 1
+              bt = MiniTest::filter_backtrace(e.backtrace).join "\n    "
+              "Error:\n#{meth}(#{klass}):\n#{e.class}: #{e.message}\n    #{bt}\n"
+            end
+        @report << e
+        e[0, 1]
+      end
+
+      def status(*args)
+        result = super
+        raise @interrupt if @interrupt
+        result
+      end
+    end
+
+    class AutoRunner
+      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)
+        @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
+        @argv = argv
+      end
+
+      def process_args(*args)
+        @runner.process_args(*args)
+        !@to_run.empty?
+      end
+
+      def run
+        @runner.run(@argv) || true
+      end
+
+      def self.run(*args)
+        new(*args).run
+      end
+    end
+  end
+end
+
+Test::Unit::Runner.autorun

data/lib/test/unit/assertions.rb

@@ -0,0 +1,324 @@
+require 'minitest/unit'
+require 'pp'
+
+module Test
+  module Unit
+    module Assertions
+      include MiniTest::Assertions
+
+      def mu_pp(obj) #:nodoc:
+        obj.pretty_inspect.chomp
+      end
+
+      MINI_DIR = File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), "minitest") #:nodoc:
+
+      UNASSIGNED = Object.new # :nodoc:
+
+      # :call-seq:
+      #   assert( test, failure_message = UNASSIGNED )
+      #
+      #Tests if +test+ is true.
+      #
+      #+msg+ may be a String or a Proc. If +msg+ is a String, it will be used
+      #as the failure message. Otherwise, the result of calling +msg+ will be
+      #used as the message if the assertion fails.
+      #
+      #If no +msg+ is given, a default message will be used.
+      #
+      #    assert(false, "This was expected to be true")
+      def assert(test, msg = UNASSIGNED)
+        case msg
+        when UNASSIGNED
+          msg = nil
+        when String, Proc
+        else
+          bt = caller.reject { |s| s.rindex(MINI_DIR, 0) }
+          raise ArgumentError, "assertion message must be String or Proc, but #{msg.class} was given.", bt
+        end
+        super
+      end
+
+      # :call-seq:
+      #   assert_block( failure_message = nil )
+      #
+      #Tests the result of the given block. If the block does not return true,
+      #the assertion will fail. The optional +failure_message+ argument is the same as in
+      #Assertions#assert.
+      #
+      #    assert_block do
+      #      [1, 2, 3].any? { |num| num < 1 }
+      #    end
+      def assert_block(*msgs)
+        assert yield, *msgs
+      end
+
+      # :call-seq:
+      #   assert_raise( *args, &block )
+      #
+      #Tests if the given block raises an exception. Acceptable exception
+      #types maye be given as optional arguments. If the last argument is a
+      #String, it will be used as the error message.
+      #
+      #    assert_raise do #Fails, no Exceptions are raised
+      #    end
+      #
+      #    assert_raise NameError do
+      #      puts x  #Raises NameError, so assertion succeeds
+      #    end
+      def assert_raise(*args, &b)
+        assert_raises(*args, &b)
+      end
+
+      # :call-seq:
+      #   assert_nothing_raised( *args, &block )
+      #
+      #If any exceptions are given as arguments, the assertion will
+      #fail if one of those exceptions are raised. Otherwise, the test fails
+      #if any exceptions are raised.
+      #
+      #The final argument may be a failure message.
+      #
+      #    assert_nothing_raised RuntimeError do
+      #      raise Exception #Assertion passes, Exception is not a RuntimeError
+      #    end
+      #
+      #    assert_nothing_raised do
+      #      raise Exception #Assertion fails
+      #    end
+      def assert_nothing_raised(*args)
+        self._assertions += 1
+        if Module === args.last
+          msg = nil
+        else
+          msg = args.pop
+        end
+        begin
+          line = __LINE__; yield
+        rescue MiniTest::Skip
+          raise
+        rescue Exception => e
+          bt = e.backtrace
+          as = e.instance_of?(MiniTest::Assertion)
+          if as
+            ans = /\A#{Regexp.quote(__FILE__)}:#{line}:in /o
+            bt.reject! {|ln| ans =~ ln}
+          end
+          if ((args.empty? && !as) ||
+              args.any? {|a| a.instance_of?(Module) ? e.is_a?(a) : e.class == a })
+            msg = message(msg) { "Exception raised:\n<#{mu_pp(e)}>" }
+            raise MiniTest::Assertion, msg.call, bt
+          else
+            raise
+          end
+        end
+        nil
+      end
+
+      # :call-seq:
+      #   assert_nothing_thrown( failure_message = nil, &block )
+      #
+      #Fails if the given block uses a call to Kernel#throw.
+      #
+      #An optional failure message may be provided as the final argument.
+      #
+      #    assert_nothing_thrown "Something was thrown!" do
+      #      throw :problem?
+      #    end
+      def assert_nothing_thrown(msg=nil)
+        begin
+          yield
+        rescue ArgumentError => error
+          raise error if /\Auncaught throw (.+)\z/m !~ error.message
+          msg = message(msg) { "<#{$1}> was thrown when nothing was expected" }
+          flunk(msg)
+        end
+        assert(true, "Expected nothing to be thrown")
+      end
+
+      # :call-seq:
+      #   assert_equal( expected, actual, failure_message = nil )
+      #
+      #Tests if +expected+ is equal to +actual+.
+      #
+      #An optional failure message may be provided as the final argument.
+      def assert_equal(exp, act, msg = nil)
+        msg = message(msg) {
+          exp_str = mu_pp(exp)
+          act_str = mu_pp(act)
+          exp_comment = ''
+          act_comment = ''
+          if exp_str == act_str
+            if (exp.is_a?(String) && act.is_a?(String)) ||
+               (exp.is_a?(Regexp) && act.is_a?(Regexp))
+              exp_comment = " (#{exp.encoding})"
+              act_comment = " (#{act.encoding})"
+            elsif exp.is_a?(Float) && act.is_a?(Float)
+              exp_str = "%\#.#{Float::DIG+2}g" % exp
+              act_str = "%\#.#{Float::DIG+2}g" % act
+            elsif exp.is_a?(Time) && act.is_a?(Time)
+              if exp.subsec * 1000_000_000 == exp.nsec
+                exp_comment = " (#{exp.nsec}[ns])"
+              else
+                exp_comment = " (subsec=#{exp.subsec})"
+              end
+              if act.subsec * 1000_000_000 == act.nsec
+                act_comment = " (#{act.nsec}[ns])"
+              else
+                act_comment = " (subsec=#{act.subsec})"
+              end
+            elsif exp.class != act.class
+              # a subclass of Range, for example.
+              exp_comment = " (#{exp.class})"
+              act_comment = " (#{act.class})"
+            end
+          elsif !Encoding.compatible?(exp_str, act_str)
+            if exp.is_a?(String) && act.is_a?(String)
+              exp_str = exp.dump
+              act_str = act.dump
+              exp_comment = " (#{exp.encoding})"
+              act_comment = " (#{act.encoding})"
+            else
+              exp_str = exp_str.dump
+              act_str = act_str.dump
+            end
+          end
+          "<#{exp_str}>#{exp_comment} expected but was\n<#{act_str}>#{act_comment}"
+        }
+        assert(exp == act, msg)
+      end
+
+      # :call-seq:
+      #   assert_not_nil( expression, failure_message = nil )
+      #
+      #Tests if +expression+ is not nil.
+      #
+      #An optional failure message may be provided as the final argument.
+      def assert_not_nil(exp, msg=nil)
+        msg = message(msg) { "<#{mu_pp(exp)}> expected to not be nil" }
+        assert(!exp.nil?, msg)
+      end
+
+      # :call-seq:
+      #   assert_not_equal( expected, actual, failure_message = nil )
+      #
+      #Tests if +expected+ is not equal to +actual+.
+      #
+      #An optional failure message may be provided as the final argument.
+      def assert_not_equal(exp, act, msg=nil)
+        msg = message(msg) { "<#{mu_pp(exp)}> expected to be != to\n<#{mu_pp(act)}>" }
+        assert(exp != act, msg)
+      end
+
+      # :call-seq:
+      #   assert_no_match( regexp, string, failure_message = nil )
+      #
+      #Tests if the given Regexp does not match a given String.
+      #
+      #An optional failure message may be provided as the final argument.
+      def assert_no_match(regexp, string, msg=nil)
+        assert_instance_of(Regexp, regexp, "The first argument to assert_no_match should be a Regexp.")
+        self._assertions -= 1
+        msg = message(msg) { "<#{mu_pp(regexp)}> expected to not match\n<#{mu_pp(string)}>" }
+        assert(regexp !~ string, msg)
+      end
+
+      # :call-seq:
+      #   assert_not_same( expected, actual, failure_message = nil )
+      #
+      #Tests if +expected+ is not the same object as +actual+.
+      #This test uses Object#equal? to test equality.
+      #
+      #An optional failure message may be provided as the final argument.
+      #
+      #    assert_not_same("x", "x") #Succeeds
+      def assert_not_same(expected, actual, message="")
+        msg = message(msg) { build_message(message, <<EOT, expected, expected.__id__, actual, actual.__id__) }
+<?>
+with id <?> expected to not be equal\\? to
+<?>
+with id <?>.
+EOT
+        assert(!actual.equal?(expected), msg)
+      end
+
+      # :call-seq:
+      #   assert_respond_to( object, method, failure_message = nil )
+      #
+      #Tests if the given Object responds to +method+.
+      #
+      #An optional failure message may be provided as the final argument.
+      #
+      #    assert_respond_to("hello", :reverse)  #Succeeds
+      #    assert_respond_to("hello", :does_not_exist)  #Fails
+      def assert_respond_to obj, meth, msg = nil
+        #get rid of overcounting
+        super if !caller[0].rindex(MINI_DIR, 0) || !obj.respond_to?(meth)
+      end
+
+      # :call-seq:
+      #   assert_send( +send_array+, failure_message = nil )
+      #
+      # Passes if the method send returns a true value.
+      #
+      # +send_array+ is composed of:
+      # * A receiver
+      # * A method
+      # * Arguments to the method
+      #
+      # Example:
+      #   assert_send([[1, 2], :member?, 1]) # -> pass
+      #   assert_send([[1, 2], :member?, 4]) # -> fail
+      def assert_send send_ary, m = nil
+        recv, msg, *args = send_ary
+        m = message(m) {
+          if args.empty?
+            argsstr = ""
+          else
+            (argsstr = mu_pp(args)).sub!(/\A\[(.*)\]\z/m, '(\1)')
+          end
+          "Expected #{mu_pp(recv)}.#{msg}#{argsstr} to return true"
+        }
+        assert recv.__send__(msg, *args), m
+      end
+
+      # :call-seq:
+      #   assert_not_send( +send_array+, failure_message = nil )
+      #
+      # Passes if the method send doesn't return a true value.
+      #
+      # +send_array+ is composed of:
+      # * A receiver
+      # * A method
+      # * Arguments to the method
+      #
+      # Example:
+      #   assert_not_send([[1, 2], :member?, 1]) # -> fail
+      #   assert_not_send([[1, 2], :member?, 4]) # -> pass
+      def assert_not_send send_ary, m = nil
+        recv, msg, *args = send_ary
+        m = message(m) {
+          if args.empty?
+            argsstr = ""
+          else
+            (argsstr = mu_pp(args)).sub!(/\A\[(.*)\]\z/m, '(\1)')
+          end
+          "Expected #{mu_pp(recv)}.#{msg}#{argsstr} to return false"
+        }
+        assert !recv.__send__(msg, *args), m
+      end
+
+      ms = instance_methods(true).map {|sym| sym.to_s }
+      ms.grep(/\Arefute_/) do |m|
+        mname = ('assert_not_' << m.to_s[/.*?_(.*)/, 1])
+        alias_method(mname, m) unless ms.include? mname
+      end
+      alias assert_include assert_includes
+      alias assert_not_include assert_not_includes
+
+      def build_message(head, template=nil, *arguments) #:nodoc:
+        template &&= template.chomp
+        template.gsub(/\G((?:[^\\]|\\.)*?)(\\)?\?/) { $1 + ($2 ? "?" : mu_pp(arguments.shift)) }
+      end
+    end
+  end
+end

data/lib/test/unit/parallel.rb

@@ -0,0 +1,161 @@
+require 'test/unit'
+
+module Test
+  module Unit
+    class Worker < Runner
+      class << self
+        undef autorun
+      end
+
+      alias orig_run_suite _run_suite
+      undef _run_suite
+      undef _run_suites
+      undef run
+
+      def increment_io(orig)
+        *rest, io = 32.times.inject([orig.dup]){|ios, | ios << ios.last.dup }
+        rest.each(&:close)
+        io
+      end
+
+      def _run_suites(suites, type)
+        suites.map do |suite|
+          _run_suite(suite, type)
+        end
+      end
+
+      def _run_suite(suite, type)
+        r = report.dup
+        orig_testout = MiniTest::Unit.output
+        i,o = IO.pipe
+
+        MiniTest::Unit.output = o
+        orig_stdin, orig_stdout = $stdin, $stdout
+
+        th = Thread.new do
+          begin
+            while buf = (self.verbose ? i.gets : i.read(5))
+              @stdout.puts "p #{[buf].pack("m").gsub("\n","")}"
+            end
+          rescue IOError
+          rescue Errno::EPIPE
+          end
+        end
+
+        e, f, s = @errors, @failures, @skips
+
+        begin
+          result = orig_run_suite(suite, type)
+        rescue Interrupt
+          @need_exit = true
+          result = [nil,nil]
+        end
+
+        MiniTest::Unit.output = orig_testout
+        $stdin = orig_stdin
+        $stdout = orig_stdout
+
+        o.close
+        begin
+          th.join
+        rescue IOError
+          raise unless ["stream closed","closed stream"].include? $!.message
+        end
+        i.close
+
+        result << (report - r)
+        result << [@errors-e,@failures-f,@skips-s]
+        result << ($: - @old_loadpath)
+        result << suite.name
+
+        begin
+          @stdout.puts "done #{[Marshal.dump(result)].pack("m").gsub("\n","")}"
+        rescue Errno::EPIPE; end
+        return result
+      ensure
+        MiniTest::Unit.output = orig_stdout
+        $stdin = orig_stdin
+        $stdout = orig_stdout
+        o.close if o && !o.closed?
+        i.close if i && !i.closed?
+      end
+
+      def run(args = [])
+        process_args args
+        @@stop_auto_run = true
+        @opts = @options.dup
+        @need_exit = false
+
+        @old_loadpath = []
+        begin
+          @stdout = increment_io(STDOUT)
+          @stdin = increment_io(STDIN)
+          @stdout.sync = true
+          @stdout.puts "ready"
+          while buf = @stdin.gets
+            case buf.chomp
+            when /^loadpath (.+?)$/
+              @old_loadpath = $:.dup
+              $:.push(*Marshal.load($1.unpack("m")[0].force_encoding("ASCII-8BIT"))).uniq!
+            when /^run (.+?) (.+?)$/
+              @stdout.puts "okay"
+
+              @options = @opts.dup
+              suites = MiniTest::Unit::TestCase.test_suites
+
+              begin
+                require $1
+              rescue LoadError
+                @stdout.puts "after #{[Marshal.dump([$1, $!])].pack("m").gsub("\n","")}"
+                @stdout.puts "ready"
+                next
+              end
+              _run_suites MiniTest::Unit::TestCase.test_suites-suites, $2.to_sym
+
+              if @need_exit
+                begin
+                  @stdout.puts "bye"
+                rescue Errno::EPIPE; end
+                exit
+              else
+                @stdout.puts "ready"
+              end
+            when /^quit$/
+              begin
+                @stdout.puts "bye"
+              rescue Errno::EPIPE; end
+              exit
+            end
+          end
+        rescue Errno::EPIPE
+        rescue Exception => e
+          begin
+            @stdout.puts "bye #{[Marshal.dump(e)].pack("m").gsub("\n","")}"
+          rescue Errno::EPIPE;end
+          exit
+        ensure
+          @stdin.close
+          @stdout.close
+        end
+      end
+    end
+  end
+end
+
+if $0 == __FILE__
+  module Test
+    module Unit
+      class TestCase < MiniTest::Unit::TestCase
+        def on_parallel_worker?
+          true
+        end
+      end
+    end
+  end
+  require 'rubygems'
+  class Gem::TestCase < MiniTest::Unit::TestCase
+    @@project_dir = File.expand_path('../../../..', __FILE__)
+  end
+
+  Test::Unit::Worker.new.run(ARGV)
+end

data/lib/test/unit/testcase.rb

@@ -0,0 +1,25 @@
+require 'test/unit/assertions'
+
+module Test
+  module Unit
+    # remove silly TestCase class
+    remove_const(:TestCase) if defined?(self::TestCase)
+
+    class TestCase < MiniTest::Unit::TestCase
+      include Assertions
+
+      def on_parallel_worker?
+        false
+      end
+
+      def run runner
+        @options = runner.options
+        super runner
+      end
+
+      def self.test_order
+        :sorted
+      end
+    end
+  end
+end

data/minitest-spec-rails-tu-shim.gemspec

@@ -0,0 +1,15 @@
+Gem::Specification.new do |spec|
+  spec.name          = "minitest-spec-rails-tu-shim"
+  spec.version       = '1.9.3'
+  spec.authors       = ["Nobuyoshi Nakada", "Shota Fukumori", "akr", "unak", "Ryan Davis", "Aaron Patterson", "Yuki Sonoda", "NARUSE, Yui", "Yusuke Endoh", "Eric Hodel", "Kenta Murata"]
+  spec.email         = ["nobu@ruby-lang.org", "sorah@tubusu.net", "ryand-ruby@zenspider.com", "aaron.patterson@gmail.com", "ugui@yugui.jp", "drbrain@segment7.net", "mrkn+github@mrkn.jp"]
+  spec.description   = 'Redistribution of lib/test source directory from Ruby 1.9.3p392.'
+  spec.summary       = spec.description
+  spec.homepage      = "https://github.com/metaskills/minitest-spec-rails-tu-shim"
+  spec.license       = "See LICENSE.txt and COPYING.txt"
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.add_development_dependency "bundler", "~> 1.3"
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: minitest-spec-rails-tu-shim
+version: !ruby/object:Gem::Version
+  version: 1.9.3
+  prerelease: 
+platform: ruby
+authors:
+- Nobuyoshi Nakada
+- Shota Fukumori
+- akr
+- unak
+- Ryan Davis
+- Aaron Patterson
+- Yuki Sonoda
+- NARUSE, Yui
+- Yusuke Endoh
+- Eric Hodel
+- Kenta Murata
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: Redistribution of lib/test source directory from Ruby 1.9.3p392.
+email:
+- nobu@ruby-lang.org
+- sorah@tubusu.net
+- ryand-ruby@zenspider.com
+- aaron.patterson@gmail.com
+- ugui@yugui.jp
+- drbrain@segment7.net
+- mrkn+github@mrkn.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- COPYING.txt
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/test/unit.rb
+- lib/test/unit/assertions.rb
+- lib/test/unit/parallel.rb
+- lib/test/unit/testcase.rb
+- minitest-spec-rails-tu-shim.gemspec
+homepage: https://github.com/metaskills/minitest-spec-rails-tu-shim
+licenses:
+- See LICENSE.txt and COPYING.txt
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Redistribution of lib/test source directory from Ruby 1.9.3p392.
+test_files: []
+has_rdoc: