* lib/test: Removed because ruby's test cases now independent to

  lib/test by r45970. [Feature #9711] [ruby-core:62620]

  I'm still considering about the future of lib/minitest, lib/test.
  (bundling gems?)

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@45974 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

5 files changed, 0 insertions, 1582 deletions

diff --git a/lib/test/unit.rb b/lib/test/unit.rb
deleted file mode 100644
index dbdba6edc3..0000000000
--- a/lib/test/unit.rb
+++ /dev/null
@@ -1,880 +0,0 @@
-begin
-  gem 'minitest', '< 5.0.0' if defined? Gem
-rescue Gem::LoadError
-end
-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
diff --git a/lib/test/unit/assertions.rb b/lib/test/unit/assertions.rb
deleted file mode 100644
index 869baf505f..0000000000
--- a/lib/test/unit/assertions.rb
+++ /dev/null
@@ -1,461 +0,0 @@
-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:
-
-      # :call-seq:
-      #   assert(test, [failure_message])
-      #
-      #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, *msgs)
-        case msg = msgs.first
-        when String, Proc
-        when nil
-          msgs.shift
-        else
-          bt = caller.reject { |s| s.start_with?(MINI_DIR) }
-          raise ArgumentError, "assertion message must be String or Proc, but #{msg.class} was given.", bt
-        end unless msgs.empty?
-        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 may 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(*exp, &b)
-        case exp.last
-        when String, Proc
-          msg = exp.pop
-        end
-
-        begin
-          yield
-        rescue MiniTest::Skip => e
-          return e if exp.include? MiniTest::Skip
-          raise e
-        rescue Exception => e
-          expected = exp.any? { |ex|
-            if ex.instance_of? Module then
-              e.kind_of? ex
-            else
-              e.instance_of? ex
-            end
-          }
-
-          assert expected, proc {
-            exception_details(e, message(msg) {"#{mu_pp(exp)} exception expected, not"}.call)
-          }
-
-          return e
-        end
-
-        exp = exp.first if exp.size == 1
-
-        flunk(message(msg) {"#{mu_pp(exp)} expected but nothing was raised"})
-      end
-
-      # :call-seq:
-      #   assert_raise_with_message(exception, expected, msg = nil, &block)
-      #
-      #Tests if the given block raises an exception with the expected
-      #message.
-      #
-      #    assert_raise_with_message(RuntimeError, "foo") do
-      #      nil #Fails, no Exceptions are raised
-      #    end
-      #
-      #    assert_raise_with_message(RuntimeError, "foo") do
-      #      raise ArgumentError, "foo" #Fails, different Exception is raised
-      #    end
-      #
-      #    assert_raise_with_message(RuntimeError, "foo") do
-      #      raise "bar" #Fails, RuntimeError is raised but the message differs
-      #    end
-      #
-      #    assert_raise_with_message(RuntimeError, "foo") do
-      #      raise "foo" #Raises RuntimeError with the message, so assertion succeeds
-      #    end
-      def assert_raise_with_message(exception, expected, msg = nil, &block)
-        case expected
-        when String
-          assert = :assert_equal
-        when Regexp
-          assert = :assert_match
-        else
-          raise TypeError, "Expected #{expected.inspect} to be a kind of String or Regexp, not #{expected.class}"
-        end
-
-        ex = assert_raise(exception, *msg) {yield}
-        msg = message(msg, "") {"Expected Exception(#{exception}) was raised, but the message doesn't match"}
-
-        if assert == :assert_equal
-          assert_equal(expected, ex.message, msg)
-        else
-          msg = message(msg) { "Expected #{mu_pp expected} to match #{mu_pp ex.message}" }
-          assert expected =~ ex.message, msg
-          block.binding.eval("proc{|_|$~=_}").call($~)
-        end
-        ex
-      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, and
-      #returns the result of the block otherwise.
-      #
-      #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
-          ret = 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")
-        ret
-      end
-
-      # :call-seq:
-      #   assert_throw( tag, failure_message = nil, &block )
-      #
-      #Fails unless the given block throws +tag+, returns the caught
-      #value otherwise.
-      #
-      #An optional failure message may be provided as the final argument.
-      #
-      #    tag = Object.new
-      #    assert_throw(tag, "#{tag} was not thrown!") do
-      #      throw tag
-      #    end
-      def assert_throw(tag, msg = nil)
-        ret = catch(tag) do
-          begin
-            yield(tag)
-          rescue ArgumentError => e
-            raise unless thrown = e.message[/\Auncaught throw (.+)\z/m, 1]
-          end
-          msg = message(msg) {
-            "Expected #{mu_pp(tag)} to have been thrown"\
-            "#{", not #{thrown}" if thrown}"
-          }
-          assert(false, msg)
-        end
-        assert(true)
-        ret
-      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, priv), msg = nil
-        if priv
-          msg = message(msg) {
-            "Expected #{mu_pp(obj)} (#{obj.class}) to respond to ##{meth}#{" privately" if priv}"
-          }
-          return assert obj.respond_to?(meth, priv), msg
-        end
-        #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(["Hello world", :include?, "Hello"])    # -> pass
-      #   assert_send(["Hello world", :include?, "Goodbye"])  # -> 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 assert_all?(obj, m = nil, &blk)
-        failed = []
-        obj.each do |*a, &b|
-          unless blk.call(*a, &b)
-            failed << (a.size > 1 ? a : a[0])
-          end
-        end
-        assert(failed.empty?, message(m) {failed.pretty_inspect})
-      end
-
-      def assert_not_all?(obj, m = nil, &blk)
-        failed = []
-        obj.each do |*a, &b|
-          if blk.call(*a, &b)
-            failed << a.size > 1 ? a : a[0]
-          end
-        end
-        assert(failed.empty?, message(m) {failed.pretty_inspect})
-      end
-
-      def build_message(head, template=nil, *arguments) #:nodoc:
-        template &&= template.chomp
-        template.gsub(/\G((?:[^\\]|\\.)*?)(\\)?\?/) { $1 + ($2 ? "?" : mu_pp(arguments.shift)) }
-      end
-
-      def message(msg = nil, *args, &default) # :nodoc:
-        if Proc === msg
-          super(nil, *args) do
-            [msg.call, (default.call if default)].compact.reject(&:empty?).join(".\n")
-          end
-        else
-          super
-        end
-      end
-    end
-  end
-end
diff --git a/lib/test/unit/parallel.rb b/lib/test/unit/parallel.rb
deleted file mode 100644
index 92cc7ec44b..0000000000
--- a/lib/test/unit/parallel.rb
+++ /dev/null
@@ -1,189 +0,0 @@
-require 'test/unit'
-
-module Test
-  module Unit
-    class Worker < Runner # :nodoc:
-      class << self
-        undef autorun
-      end
-
-      alias orig_run_suite mini_run_suite
-      undef _run_suite
-      undef _run_suites
-      undef run
-
-      def increment_io(orig) # :nodoc:
-        *rest, io = 32.times.inject([orig.dup]){|ios, | ios << ios.last.dup }
-        rest.each(&:close)
-        io
-      end
-
-      def _run_suites(suites, type) # :nodoc:
-        suites.map do |suite|
-          _run_suite(suite, type)
-        end
-      end
-
-      def _run_suite(suite, type) # :nodoc:
-        @partial_report = []
-        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))
-              _report "p", buf
-            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 << @partial_report
-        @partial_report = nil
-        result << [@errors-e,@failures-f,@skips-s]
-        result << ($: - @old_loadpath)
-        result << suite.name
-
-        begin
-          _report "done", Marshal.dump(result)
-        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 = []) # :nodoc:
-        process_args args
-        @@stop_auto_run = true
-        @opts = @options.dup
-        @need_exit = false
-
-        @old_loadpath = []
-        begin
-          begin
-            @stdout = increment_io(STDOUT)
-            @stdin = increment_io(STDIN)
-          rescue
-            exit 2
-          end
-          exit 2 unless @stdout && @stdin
-
-          @stdout.sync = true
-          _report "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 (.+?) (.+?)$/
-              _report "okay"
-
-              @options = @opts.dup
-              suites = MiniTest::Unit::TestCase.test_suites
-
-              begin
-                require $1
-              rescue LoadError
-                _report "after", Marshal.dump([$1, ProxyError.new($!)])
-                _report "ready"
-                next
-              end
-              _run_suites MiniTest::Unit::TestCase.test_suites-suites, $2.to_sym
-
-              if @need_exit
-                begin
-                  _report "bye"
-                rescue Errno::EPIPE; end
-                exit
-              else
-                _report "ready"
-              end
-            when /^quit$/
-              begin
-                _report "bye"
-              rescue Errno::EPIPE; end
-              exit
-            end
-          end
-        rescue Errno::EPIPE
-        rescue Exception => e
-          begin
-            trace = e.backtrace
-            err = ["#{trace.shift}: #{e.message} (#{e.class})"] + trace.map{|t| t.prepend("\t") }
-
-            _report "bye", Marshal.dump(err.join("\n"))
-          rescue Errno::EPIPE;end
-          exit
-        ensure
-          @stdin.close if @stdin
-          @stdout.close if @stdout
-        end
-      end
-
-      def _report(res, *args) # :nodoc:
-        res = "#{res} #{args.pack("m0")}" unless args.empty?
-        @stdout.puts(res)
-      end
-
-      def puke(klass, meth, e) # :nodoc:
-        if e.is_a?(MiniTest::Skip)
-          new_e = MiniTest::Skip.new(e.message)
-          new_e.set_backtrace(e.backtrace)
-          e = new_e
-        end
-        @partial_report << [klass.name, meth, e.is_a?(MiniTest::Assertion) ? e : ProxyError.new(e)]
-        super
-      end
-    end
-  end
-end
-
-if $0 == __FILE__
-  module Test
-    module Unit
-      class TestCase < MiniTest::Unit::TestCase # :nodoc: all
-        undef on_parallel_worker?
-        def on_parallel_worker?
-          true
-        end
-      end
-    end
-  end
-  require 'rubygems'
-  module Gem # :nodoc:
-  end
-  class Gem::TestCase < MiniTest::Unit::TestCase # :nodoc:
-    @@project_dir = File.expand_path('../../../..', __FILE__)
-  end
-
-  Test::Unit::Worker.new.run(ARGV)
-end
diff --git a/lib/test/unit/test-unit.gemspec b/lib/test/unit/test-unit.gemspec
deleted file mode 100644
index 363fd50c02..0000000000
--- a/lib/test/unit/test-unit.gemspec
+++ /dev/null
@@ -1,18 +0,0 @@
-# -*- ruby -*-
-
-Gem::Specification.new do |s|
-  s.name = "test-unit"
-  s.version = "#{RUBY_VERSION}.0"
-  s.homepage = "http://www.ruby-lang.org"
-  s.author = "Shota Fukumori"
-  s.email = "sorah@tubusu.net"
-  s.summary = "test/unit compatible API testing framework"
-  s.description =
-    "This library implements test/unit compatible API on minitest. " +
-    "The test/unit means that test/unit which was bundled with Ruby 1.8."
-  s.executables = ["testrb"]
-
-  # Ruby bundled test/unit is a compatibility layer for minitest,
-  # and it doesn't have support for minitest 5.
-  s.add_runtime_dependency "minitest", '< 5.0.0'
-end
diff --git a/lib/test/unit/testcase.rb b/lib/test/unit/testcase.rb
deleted file mode 100644
index 984f08dd32..0000000000
--- a/lib/test/unit/testcase.rb
+++ /dev/null
@@ -1,34 +0,0 @@
-require 'test/unit/assertions'
-
-module Test
-  module Unit
-    # remove silly TestCase class
-    remove_const(:TestCase) if defined?(self::TestCase)
-
-    class TestCase < MiniTest::Unit::TestCase # :nodoc: all
-      include Assertions
-
-      def on_parallel_worker?
-        false
-      end
-
-      def run runner
-        @options = runner.options
-        super runner
-      end
-
-      def self.test_order
-        :sorted
-      end
-
-      def self.method_added(name)
-        return unless name.to_s.start_with?("test_")
-        @test_methods ||= {}
-        if @test_methods[name]
-          warn "test/unit warning: method #{ self }##{ name } is redefined"
-        end
-        @test_methods[name] = true
-      end
-    end
-  end
-end