Move to tool/lib from test/lib.

4 files changed, 2403 insertions, 0 deletions

diff --git a/tool/lib/test/unit.rb b/tool/lib/test/unit.rb
new file mode 100644
index 0000000000..3df6774d61
--- /dev/null
+++ b/tool/lib/test/unit.rb
@@ -0,0 +1,1175 @@
+# frozen_string_literal: true
+begin
+  gem 'minitest', '< 5.0.0' if defined? Gem
+rescue Gem::LoadError
+end
+require 'minitest/unit'
+require 'test/unit/assertions'
+require_relative '../envutil'
+require_relative '../../../tool/colorize'
+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)
+        @run_options = orig_args
+        @help = orig_args.map { |s| s =~ /[\s|&<>$()]/ ? s.inspect : s }.join " "
+        @options = 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 method names on pattern: /REGEXP/, !/REGEXP/ or STRING" do |a|
+          (options[:filter] ||= []) << a
+        end
+
+        opts.on '--test-order=random|alpha|sorted', [:random, :alpha, :sorted] do |a|
+          MiniTest::Unit::TestCase.test_order = a
+        end
+      end
+
+      def non_options(files, options)
+        filter = options[:filter]
+        if filter
+          pos_pat = /\A\/(.*)\/\z/
+          neg_pat = /\A!\/(.*)\/\z/
+          negative, positive = filter.partition {|s| neg_pat =~ s}
+          if positive.empty?
+            filter = nil
+          elsif negative.empty? and positive.size == 1 and pos_pat !~ positive[0]
+            filter = positive[0]
+          else
+            filter = Regexp.union(*positive.map! {|s| Regexp.new(s[pos_pat, 1] || "\\A#{Regexp.quote(s)}\\z")})
+          end
+          unless negative.empty?
+            negative = Regexp.union(*negative.map! {|s| Regexp.new(s[neg_pat, 1])})
+            filter = /\A(?=.*#{filter})(?!.*#{negative})/
+          end
+          if Regexp === filter
+            # bypass conversion in minitest
+            def filter.=~(other)    # :nodoc:
+              super unless Regexp === other
+            end
+          end
+          options[:filter] = filter
+        end
+        true
+      end
+    end
+
+    module Parallel # :nodoc: all
+      def process_args(args = [])
+        return @options if @options
+        options = super
+        if @options[:parallel]
+          @files = args
+        end
+        options
+      end
+
+      def non_options(files, options)
+        @jobserver = nil
+        makeflags = ENV.delete("MAKEFLAGS")
+        if !options[:parallel] and
+          /(?:\A|\s)--jobserver-(?:auth|fds)=(\d+),(\d+)/ =~ makeflags
+          begin
+            r = IO.for_fd($1.to_i(10), "rb", autoclose: false)
+            w = IO.for_fd($2.to_i(10), "wb", autoclose: false)
+          rescue
+            r.close if r
+            nil
+          else
+            r.close_on_exec = true
+            w.close_on_exec = true
+            @jobserver = [r, w]
+            options[:parallel] ||= 1
+          end
+        end
+        super
+      end
+
+      def status(*args)
+        result = super
+        raise @interrupt if @interrupt
+        result
+      end
+
+      private
+      def setup_options(opts, options)
+        super
+
+        opts.separator "parallel test options:"
+
+        options[:retry] = true
+
+        opts.on '-j N', '--jobs N', /\A(t)?(\d+)\z/, "Allow run tests with N jobs at once" do |_, t, a|
+          options[:testing] = true & t # For testing
+          options[:parallel] = a.to_i
+        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 which is used at -j option" do |a|
+          options[:ruby] = a.split(/ /).reject(&:empty?)
+        end
+      end
+
+      class Worker
+        def self.launch(ruby,args=[])
+          scale = EnvUtil.timeout_scale
+          io = IO.popen([*ruby, "-W1",
+                        "#{File.dirname(__FILE__)}/unit/parallel.rb",
+                        *("--timeout-scale=#{scale}" if scale),
+                        *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/ =~ $!.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"
+        rescue Errno::EPIPE => e
+          warn "#{@pid}:#{@status.to_s.ljust(7)}:#{@file}: #{e.message}"
+        end
+
+        def kill
+          Process.kill(:KILL, @pid)
+        rescue Errno::ESRCH
+        end
+
+        def died(*additional)
+          @status = :quit
+          @io.close
+          status = $?
+          if status and status.signaled?
+            additional[0] ||= SignalException.new(status.termsig)
+          end
+
+          call_hook(:dead,*additional)
+        end
+
+        def to_s
+          if @file and @status != :ready
+            "#{@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
+
+      def flush_job_tokens
+        if @jobserver
+          r, w = @jobserver.shift(2)
+          @jobserver = nil
+          w << @job_tokens.slice!(0..-1)
+          r.close
+          w.close
+        end
+      end
+
+      def after_worker_down(worker, e=nil, c=false)
+        return unless @options[:parallel]
+        return if @interrupt
+        flush_job_tokens
+        warn e if e
+        real_file = worker.real_file and warn "running file: #{real_file}"
+        @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 after_worker_quit(worker)
+        return unless @options[:parallel]
+        return if @interrupt
+        worker.close
+        if @jobserver and (token = @job_tokens.slice!(0))
+          @jobserver[1] << token
+        end
+        @workers.delete(worker)
+        @dead_workers << worker
+        @ios = @workers.map(&:io)
+      end
+
+      def launch_worker
+        begin
+          worker = Worker.launch(@options[:ruby], @run_options)
+        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.timeout(1) do
+              worker.quit
+            end
+          rescue Errno::EPIPE
+          rescue Timeout::Error
+          end
+          worker.close
+        end
+
+        return if @workers.empty?
+        begin
+          Timeout.timeout(0.2 * @workers.size) do
+            Process.waitall
+          end
+        rescue Timeout::Error
+          @workers.each do |worker|
+            worker.kill
+          end
+          @worker.clear
+        end
+      end
+
+      FakeClass = Struct.new(:name)
+      def fake_class(name)
+        (@fake_classes ||= {})[name] ||= FakeClass.new(name)
+      end
+
+      def deal(io, type, result, rep, shutting_down = false)
+        worker = @workers_hash[io]
+        cmd = worker.read
+        cmd.sub!(/\A\.+/, '') if cmd # read may return nil
+        case cmd
+        when ''
+          # just only dots, ignore
+        when /^okay$/
+          worker.status = :running
+        when /^ready(!)?$/
+          bang = $1
+          worker.status = :ready
+
+          unless task = @tasks.shift
+            worker.quit
+            return nil
+          end
+          if @options[:separate] and not bang
+            worker.quit
+            worker = launch_worker
+          end
+          worker.run(task, type)
+          @test_count += 1
+
+          jobs_status(worker)
+        when /^done (.+?)$/
+          begin
+            r = Marshal.load($1.unpack("m")[0])
+          rescue
+            print "unknown object: #{$1.unpack("m")[0].dump}"
+            return true
+          end
+          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!
+          jobs_status(worker) if @options[:job_status] == :replace
+          return true
+        when /^record (.+?)$/
+          begin
+            r = Marshal.load($1.unpack("m")[0])
+          rescue => e
+            print "unknown record: #{e.message} #{$1.unpack("m")[0].dump}"
+            return true
+          end
+          record(fake_class(r[0]), *r[1..-1])
+        when /^p (.+?)$/
+          del_jobs_status
+          print $1.unpack("m")[0]
+          jobs_status(worker) 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
+        else
+          print "unknown command: #{cmd.dump}\n"
+        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 thing for parallel running
+        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
+        @job_tokens   = String.new(encoding: Encoding::ASCII_8BIT) if @jobserver
+        begin
+          [@tasks.size, @options[:parallel]].min.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
+            if @jobserver and @job_tokens and !@tasks.empty? and !@workers.any? {|x| x.status == :ready}
+              t = @jobserver[0].read_nonblock([@tasks.size, @options[:parallel]].min, exception: false)
+              if String === t
+                @job_tokens << t
+                t.size.times {launch_worker}
+              end
+            end
+          end
+        rescue Interrupt => ex
+          @interrupt = ex
+          return result
+        ensure
+          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
+          flush_job_tokens
+
+          unless @interrupt || !@options[:retry] || @need_quit
+            parallel = @options[:parallel]
+            @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 "\n""Retrying..."
+              _run_suites(suites, type)
+            end
+            @options[:parallel] = parallel
+          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
+        del_status_line
+        result
+      end
+    end
+
+    module Skipping # :nodoc: all
+      def failed(s)
+        super if !s or @options[:hide_skip]
+      end
+
+      private
+      def setup_options(opts, options)
+        super
+
+        opts.separator "skipping options:"
+
+        options[:hide_skip] = true
+
+        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
+      end
+
+      def _run_suites(suites, type)
+        result = super
+        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) }
+        failed(nil)
+        result
+      end
+    end
+
+    module Statistics
+      def update_list(list, rec, max)
+        if i = list.empty? ? 0 : list.bsearch_index {|*a| yield(*a)}
+          list[i, 0] = [rec]
+          list[max..-1] = [] if list.size >= max
+        end
+      end
+
+      def record(suite, method, assertions, time, error)
+        if @options.values_at(:longest, :most_asserted).any?
+          @tops ||= {}
+          rec = [suite.name, method, assertions, time, error]
+          if max = @options[:longest]
+            update_list(@tops[:longest] ||= [], rec, max) {|_,_,_,t,_|t<time}
+          end
+          if max = @options[:most_asserted]
+            update_list(@tops[:most_asserted] ||= [], rec, max) {|_,_,a,_,_|a<assertions}
+          end
+        end
+        # (((@record ||= {})[suite] ||= {})[method]) = [assertions, time, error]
+        super
+      end
+
+      def run(*args)
+        result = super
+        if @tops ||= nil
+          @tops.each do |t, list|
+            if list
+              puts "#{t.to_s.tr('_', ' ')} tests:"
+              list.each {|suite, method, assertions, time, error|
+                printf "%5.2fsec(%d): %s#%s\n", time, assertions, suite, method
+              }
+            end
+          end
+        end
+        result
+      end
+
+      private
+      def setup_options(opts, options)
+        super
+        opts.separator "statistics options:"
+        opts.on '--longest=N', Integer, 'Show longest N tests' do |n|
+          options[:longest] = n
+        end
+        opts.on '--most-asserted=N', Integer, 'Show most asserted N tests' do |n|
+          options[:most_asserted] = n
+        end
+      end
+    end
+
+    module StatusLine # :nodoc: all
+      def terminal_width
+        unless @terminal_width ||= nil
+          begin
+            require 'io/console'
+            width = $stdout.winsize[1]
+          rescue LoadError, NoMethodError, Errno::ENOTTY, Errno::EBADF, Errno::EINVAL
+            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(flush = true)
+        @status_line_size ||= 0
+        if @options[:job_status] == :replace
+          $stdout.print "\r"+" "*@status_line_size+"\r"
+        else
+          $stdout.puts if @status_line_size > 0
+        end
+        $stdout.flush if flush
+        @status_line_size = 0
+      end
+
+      def add_status(line)
+        @status_line_size ||= 0
+        if @options[:job_status] == :replace
+          line = line[0...(terminal_width-@status_line_size)]
+        end
+        print line
+        @status_line_size += line.size
+      end
+
+      def jobs_status(worker)
+        return if !@options[:job_status] or @options[:verbose]
+        if @options[:job_status] == :replace
+          status_line = @workers.map(&:to_s).join(" ")
+        else
+          status_line = worker.to_s
+        end
+        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 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 = true if @tty || @options[:job_status] == :replace
+        else
+          color = false
+        end
+        @colorize = Colorize.new(color, colors_file: File.join(__dir__, "../../colors"))
+        if color or @options[:job_status] == :replace
+          @verbose = !options[:parallel]
+        end
+        @output = Output.new(self) unless @options[:testing]
+        filter = options[:filter]
+        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)
+        del_status_line(false)
+        add_status(@colorize.pass("[#{count}/#{@total_tests}]"))
+        add_status(" #{s}")
+        $stdout.print "\r" if @options[:job_status] == :replace and !@verbose
+        $stdout.flush
+      end
+
+      def _print(s); $stdout.print(s); end
+      def succeed; del_status_line; end
+
+      def failed(s)
+        return if s and @options[:job_status] != :replace
+        sep = "\n"
+        @report_count ||= 0
+        report.each do |msg|
+          if msg.start_with? "Skipped:"
+            if @options[:hide_skip]
+              del_status_line
+              next
+            end
+            color = :skip
+          else
+            color = :fail
+          end
+          first, msg = msg.split(/$/, 2)
+          first = sprintf("%3d) %s", @report_count += 1, first)
+          $stdout.print(sep, @colorize.decorate(first, color), msg, "\n")
+          sep = nil
+        end
+        report.clear
+      end
+
+      def initialize
+        super
+        @tty = $stdout.tty?
+      end
+
+      def run(*args)
+        result = super
+        puts "\nruby -v: #{RUBY_DESCRIPTION}"
+        result
+      end
+
+      private
+      def setup_options(opts, options)
+        super
+
+        opts.separator "status line options:"
+
+        options[:job_status] = nil
+
+        opts.on '--jobs-status [TYPE]', [:normal, :replace, :none],
+                "Show status of jobs every file; Disabled when --jobs isn't specified." do |type|
+          options[:job_status] = (type || :normal if type != :none)
+        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
+
+      class Output < 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")
+          when /\A\.+\z/
+            runner.succeed
+          when /\A[EFS]\z/
+            runner.failed(s)
+          else
+            $stdout.print(s)
+          end
+        end
+      end
+    end
+
+    module LoadPathOption # :nodoc: all
+      def non_options(files, options)
+        begin
+          require "rbconfig"
+        rescue LoadError
+          warn "#{caller(1, 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
+
+        super
+      end
+
+      def setup_options(parser, options)
+        super
+        parser.separator "load path options:"
+        parser.on '-Idirectory', 'Add library load path' do |dirs|
+          dirs.split(':').each { |d| $LOAD_PATH.unshift d }
+        end
+      end
+    end
+
+    module GlobOption # :nodoc: all
+      @@testfile_prefix = "test"
+      @@testfile_suffix = "test"
+
+      def setup_options(parser, options)
+        super
+        parser.separator "globbing options:"
+        parser.on '-b', '--basedir=DIR', 'Base directory of test suites.' do |dir|
+          options[:base_directory] = dir
+        end
+        parser.on '-x', '--exclude REGEXP', '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"#{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 f.end_with?(File::SEPARATOR) or !f.include?(File::SEPARATOR) or File.directory?(path)
+              match = (Dir["#{path}/**/#{@@testfile_prefix}_*.rb"] + Dir["#{path}/**/*_#{@@testfile_suffix}.rb"]).uniq
+            else
+              match = Dir[path]
+            end
+            if !match.empty?
+              if reject
+                match.reject! {|n|
+                  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 GCStressOption # :nodoc: all
+      def setup_options(parser, options)
+        super
+        parser.separator "GC options:"
+        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
+        errors = {}
+        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
+            next if errors[$!.message]
+            errors[$!.message] = true
+            puts "#{f}: #{$!}"
+          end
+        }
+        result
+      end
+    end
+
+    module RepeatOption # :nodoc: all
+      def setup_options(parser, options)
+        super
+        options[:repeat_count] = nil
+        parser.separator "repeat options:"
+        parser.on '--repeat-count=NUM', "Number of times to repeat", Integer do |n|
+          options[:repeat_count] = n
+        end
+      end
+
+      def _run_anything(type)
+        @repeat_count = @options[:repeat_count]
+        super
+      end
+    end
+
+    module ExcludesOption # :nodoc: all
+      class ExcludedMethods < Struct.new(:excludes)
+        def exclude(name, reason)
+          excludes[name] = reason
+        end
+
+        def exclude_from(klass)
+          excludes = self.excludes
+          pattern = excludes.keys.grep(Regexp).tap {|k|
+            break (Regexp.new(k.join('|')) unless k.empty?)
+          }
+          klass.class_eval do
+            public_instance_methods(false).each do |method|
+              if excludes[method] or (pattern and pattern =~ method)
+                remove_method(method)
+              end
+            end
+            public_instance_methods(true).each do |method|
+              if excludes[method] or (pattern and pattern =~ method)
+                undef_method(method)
+              end
+            end
+          end
+        end
+
+        def self.load(dirs, name)
+          return unless dirs and name
+          instance = nil
+          dirs.each do |dir|
+            path = File.join(dir, name.gsub(/::/, '/') + ".rb")
+            begin
+              src = File.read(path)
+            rescue Errno::ENOENT
+              nil
+            else
+              instance ||= new({})
+              instance.instance_eval(src, path)
+            end
+          end
+          instance
+        end
+      end
+
+      def setup_options(parser, options)
+        super
+        if excludes = ENV["EXCLUDES"]
+          excludes = excludes.split(File::PATH_SEPARATOR)
+        end
+        options[:excludes] = excludes || []
+        parser.separator "excludes options:"
+        parser.on '-X', '--excludes-dir DIRECTORY', "Directory name of exclude files" do |d|
+          options[:excludes].concat d.split(File::PATH_SEPARATOR)
+        end
+      end
+
+      def _run_suite(suite, type)
+        if ex = ExcludedMethods.load(@options[:excludes], suite.name)
+          ex.exclude_from(suite)
+        end
+        super
+      end
+    end
+
+    module TimeoutOption
+      def setup_options(parser, options)
+        super
+        parser.separator "timeout options:"
+        parser.on '--timeout-scale NUM', '--subprocess-timeout-scale NUM', "Scale timeout", Float do |scale|
+          raise OptionParser::InvalidArgument, "timeout scale must be positive" unless scale > 0
+          options[:timeout_scale] = scale
+        end
+      end
+
+      def non_options(files, options)
+        if scale = options[:timeout_scale] or
+          (scale = ENV["RUBY_TEST_TIMEOUT_SCALE"] || ENV["RUBY_TEST_SUBPROCESS_TIMEOUT_SCALE"] and
+           (scale = scale.to_f) > 0)
+          EnvUtil.timeout_scale = scale
+        end
+        super
+      end
+    end
+
+    class Runner < MiniTest::Unit # :nodoc: all
+      include Test::Unit::Options
+      include Test::Unit::StatusLine
+      include Test::Unit::Parallel
+      include Test::Unit::Statistics
+      include Test::Unit::Skipping
+      include Test::Unit::GlobOption
+      include Test::Unit::RepeatOption
+      include Test::Unit::LoadPathOption
+      include Test::Unit::GCStressOption
+      include Test::Unit::ExcludesOption
+      include Test::Unit::TimeoutOption
+      include Test::Unit::RunCount
+
+      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
+
+      alias mini_run_suite _run_suite
+
+      # 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
+    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
+  test_order = self.test_order
+  class << self
+    attr_writer :test_order
+    undef test_order
+  end
+  def self.test_order
+    defined?(@test_order) ? @test_order : superclass.test_order
+  end
+  self.test_order = test_order
+  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/tool/lib/test/unit/assertions.rb b/tool/lib/test/unit/assertions.rb
new file mode 100644
index 0000000000..169a3dcc7e
--- /dev/null
+++ b/tool/lib/test/unit/assertions.rb
@@ -0,0 +1,984 @@
+# frozen_string_literal: true
+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
+        ensure
+          unless e
+            exp = exp.first if exp.size == 1
+
+            flunk(message(msg) {"#{mu_pp(exp)} expected but nothing was raised"})
+          end
+        end
+      end
+
+      def assert_raises(*exp, &b)
+        raise NoMethodError, "use assert_raise", caller
+      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 = m = nil
+        EnvUtil.with_default_internal(expected.encoding) do
+          ex = assert_raise(exception, msg || proc {"Exception(#{exception}) with message matches to #{expected.inspect}"}) do
+            yield
+          end
+          m = ex.message
+        end
+        msg = message(msg, "") {"Expected Exception(#{exception}) was raised, but the message doesn't match"}
+
+        if assert == :assert_equal
+          assert_equal(expected, m, msg)
+        else
+          msg = message(msg) { "Expected #{mu_pp expected} to match #{mu_pp m}" }
+          assert expected =~ m, 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
+      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 UncaughtThrowError => e
+            thrown = e.tag
+          end
+          msg = message(msg) {
+            "Expected #{mu_pp(tag)} to have been thrown"\
+            "#{%Q[, 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)
+        unless priv.empty?
+          msg = message(msg) {
+            "Expected #{mu_pp(obj)} (#{obj.class}) to respond to ##{meth}#{" privately" if priv[0]}"
+          }
+          return assert obj.respond_to?(meth, *priv), msg
+        end
+        #get rid of overcounting
+        if caller_locations(1, 1)[0].path.start_with?(MINI_DIR)
+          return if obj.respond_to?(meth)
+        end
+        super(obj, meth, msg)
+      end
+
+      # :call-seq:
+      #   assert_not_respond_to( object, method, failure_message = nil )
+      #
+      #Tests if the given Object does not respond to +method+.
+      #
+      #An optional failure message may be provided as the final argument.
+      #
+      #    assert_not_respond_to("hello", :reverse)  #Fails
+      #    assert_not_respond_to("hello", :does_not_exist)  #Succeeds
+      def assert_not_respond_to(obj, (meth, *priv), msg = nil)
+        unless priv.empty?
+          msg = message(msg) {
+            "Expected #{mu_pp(obj)} (#{obj.class}) to not respond to ##{meth}#{" privately" if priv[0]}"
+          }
+          return assert !obj.respond_to?(meth, *priv), msg
+        end
+        #get rid of overcounting
+        if caller_locations(1, 1)[0].path.start_with?(MINI_DIR)
+          return unless obj.respond_to?(meth)
+        end
+        refute_respond_to(obj, meth, msg)
+      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_'.dup << 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
+
+      # compatibility with test-unit
+      alias pend skip
+
+      if defined?(RubyVM::InstructionSequence)
+        def syntax_check(code, fname, line)
+          code = code.dup.force_encoding(Encoding::UTF_8)
+          RubyVM::InstructionSequence.compile(code, fname, fname, line)
+          :ok
+        end
+      else
+        def syntax_check(code, fname, line)
+          code = code.b
+          code.sub!(/\A(?:\xef\xbb\xbf)?(\s*\#.*$)*(\n)?/n) {
+            "#$&#{"\n" if $1 && !$2}BEGIN{throw tag, :ok}\n"
+          }
+          code = code.force_encoding(Encoding::UTF_8)
+          catch {|tag| eval(code, binding, fname, line - 1)}
+        end
+      end
+
+      def prepare_syntax_check(code, fname = nil, mesg = nil, verbose: nil)
+        fname ||= caller_locations(2, 1)[0]
+        mesg ||= fname.to_s
+        verbose, $VERBOSE = $VERBOSE, verbose
+        case
+        when Array === fname
+          fname, line = *fname
+        when defined?(fname.path) && defined?(fname.lineno)
+          fname, line = fname.path, fname.lineno
+        else
+          line = 1
+        end
+        yield(code, fname, line, message(mesg) {
+                if code.end_with?("\n")
+                  "```\n#{code}```\n"
+                else
+                  "```\n#{code}\n```\n""no-newline"
+                end
+              })
+      ensure
+        $VERBOSE = verbose
+      end
+
+      def assert_valid_syntax(code, *args, **opt)
+        prepare_syntax_check(code, *args, **opt) do |src, fname, line, mesg|
+          yield if defined?(yield)
+          assert_nothing_raised(SyntaxError, mesg) do
+            assert_equal(:ok, syntax_check(src, fname, line), mesg)
+          end
+        end
+      end
+
+      def assert_syntax_error(code, error, *args)
+        prepare_syntax_check(code, *args) do |src, fname, line, mesg|
+          yield if defined?(yield)
+          e = assert_raise(SyntaxError, mesg) do
+            syntax_check(src, fname, line)
+          end
+          assert_match(error, e.message, mesg)
+          e
+        end
+      end
+
+      def assert_normal_exit(testsrc, message = '', child_env: nil, **opt)
+        assert_valid_syntax(testsrc, caller_locations(1, 1)[0])
+        if child_env
+          child_env = [child_env]
+        else
+          child_env = []
+        end
+        out, _, status = EnvUtil.invoke_ruby(child_env + %W'-W0', testsrc, true, :merge_to_stdout, **opt)
+        assert !status.signaled?, FailDesc[status, message, out]
+      end
+
+      FailDesc = proc do |status, message = "", out = ""|
+        pid = status.pid
+        now = Time.now
+        faildesc = proc do
+          if signo = status.termsig
+            signame = Signal.signame(signo)
+            sigdesc = "signal #{signo}"
+          end
+          log = EnvUtil.diagnostic_reports(signame, pid, now)
+          if signame
+            sigdesc = "SIG#{signame} (#{sigdesc})"
+          end
+          if status.coredump?
+            sigdesc = "#{sigdesc} (core dumped)"
+          end
+          full_message = ''.dup
+          message = message.call if Proc === message
+          if message and !message.empty?
+            full_message << message << "\n"
+          end
+          full_message << "pid #{pid}"
+          full_message << " exit #{status.exitstatus}" if status.exited?
+          full_message << " killed by #{sigdesc}" if sigdesc
+          if out and !out.empty?
+            full_message << "\n" << out.b.gsub(/^/, '| ')
+            full_message.sub!(/(?<!\n)\z/, "\n")
+          end
+          if log
+            full_message << "Diagnostic reports:\n" << log.b.gsub(/^/, '| ')
+          end
+          full_message
+        end
+        faildesc
+      end
+
+      def assert_in_out_err(args, test_stdin = "", test_stdout = [], test_stderr = [], message = nil,
+                            success: nil, **opt)
+        args = Array(args).dup
+        args.insert((Hash === args[0] ? 1 : 0), '--disable=gems')
+        stdout, stderr, status = EnvUtil.invoke_ruby(args, test_stdin, true, true, **opt)
+        if signo = status.termsig
+          EnvUtil.diagnostic_reports(Signal.signame(signo), status.pid, Time.now)
+        end
+        if block_given?
+          raise "test_stdout ignored, use block only or without block" if test_stdout != []
+          raise "test_stderr ignored, use block only or without block" if test_stderr != []
+          yield(stdout.lines.map {|l| l.chomp }, stderr.lines.map {|l| l.chomp }, status)
+        else
+          all_assertions(message) do |a|
+            [["stdout", test_stdout, stdout], ["stderr", test_stderr, stderr]].each do |key, exp, act|
+              a.for(key) do
+                if exp.is_a?(Regexp)
+                  assert_match(exp, act)
+                elsif exp.all? {|e| String === e}
+                  assert_equal(exp, act.lines.map {|l| l.chomp })
+                else
+                  assert_pattern_list(exp, act)
+                end
+              end
+            end
+            unless success.nil?
+              a.for("success?") do
+                if success
+                  assert_predicate(status, :success?)
+                else
+                  assert_not_predicate(status, :success?)
+                end
+              end
+            end
+          end
+          status
+        end
+      end
+
+      def assert_ruby_status(args, test_stdin="", message=nil, **opt)
+        out, _, status = EnvUtil.invoke_ruby(args, test_stdin, true, :merge_to_stdout, **opt)
+        desc = FailDesc[status, message, out]
+        assert(!status.signaled?, desc)
+        message ||= "ruby exit status is not success:"
+        assert(status.success?, desc)
+      end
+
+      ABORT_SIGNALS = Signal.list.values_at(*%w"ILL ABRT BUS SEGV TERM")
+
+      def assert_separately(args, file = nil, line = nil, src, ignore_stderr: nil, **opt)
+        unless file and line
+          loc, = caller_locations(1,1)
+          file ||= loc.path
+          line ||= loc.lineno
+        end
+        src = <<eom
+# -*- coding: #{line += __LINE__; src.encoding}; -*-
+  require #{__dir__.dump};include Test::Unit::Assertions
+  END {
+    puts [Marshal.dump($!)].pack('m'), "assertions=\#{self._assertions}"
+  }
+#{line -= __LINE__; src}
+  class Test::Unit::Runner
+    @@stop_auto_run = true
+  end
+eom
+        args = args.dup
+        args.insert((Hash === args.first ? 1 : 0), "-w", "--disable=gems", *$:.map {|l| "-I#{l}"})
+        stdout, stderr, status = EnvUtil.invoke_ruby(args, src, true, true, **opt)
+        abort = status.coredump? || (status.signaled? && ABORT_SIGNALS.include?(status.termsig))
+        assert(!abort, FailDesc[status, nil, stderr])
+        self._assertions += stdout[/^assertions=(\d+)/, 1].to_i
+        begin
+          res = Marshal.load(stdout.unpack("m")[0])
+        rescue => marshal_error
+          ignore_stderr = nil
+        end
+        if res
+          if bt = res.backtrace
+            bt.each do |l|
+              l.sub!(/\A-:(\d+)/){"#{file}:#{line + $1.to_i}"}
+            end
+            bt.concat(caller)
+          else
+            res.set_backtrace(caller)
+          end
+          raise res unless SystemExit === res
+        end
+
+        # really is it succeed?
+        unless ignore_stderr
+          # the body of assert_separately must not output anything to detect error
+          assert(stderr.empty?, FailDesc[status, "assert_separately failed with error message", stderr])
+        end
+        assert(status.success?, FailDesc[status, "assert_separately failed", stderr])
+        raise marshal_error if marshal_error
+      end
+
+      def assert_warning(pat, msg = nil)
+        result = nil
+        stderr = EnvUtil.with_default_internal(pat.encoding) {
+          EnvUtil.verbose_warning {
+            result = yield
+          }
+        }
+        msg = message(msg) {diff pat, stderr}
+        assert(pat === stderr, msg)
+        result
+      end
+
+      def assert_warn(*args)
+        assert_warning(*args) {$VERBOSE = false; yield}
+      end
+
+      def assert_no_warning(pat, msg = nil)
+        result = nil
+        stderr = EnvUtil.verbose_warning {
+          EnvUtil.with_default_internal(pat.encoding) {
+            result = yield
+          }
+        }
+        msg = message(msg) {diff pat, stderr}
+        refute(pat === stderr, msg)
+        result
+      end
+
+      def assert_no_memory_leak(args, prepare, code, message=nil, limit: 2.0, rss: false, **opt)
+        # TODO: consider choosing some appropriate limit for MJIT and stop skipping this once it does not randomly fail
+        skip 'assert_no_memory_leak may consider MJIT memory usage as leak' if defined?(RubyVM::MJIT) && RubyVM::MJIT.enabled?
+
+        require_relative '../../memory_status'
+        raise MiniTest::Skip, "unsupported platform" unless defined?(Memory::Status)
+
+        token = "\e[7;1m#{$$.to_s}:#{Time.now.strftime('%s.%L')}:#{rand(0x10000).to_s(16)}:\e[m"
+        token_dump = token.dump
+        token_re = Regexp.quote(token)
+        envs = args.shift if Array === args and Hash === args.first
+        args = [
+          "--disable=gems",
+          "-r", File.expand_path("../../../memory_status", __FILE__),
+          *args,
+          "-v", "-",
+        ]
+        if defined? Memory::NO_MEMORY_LEAK_ENVS then
+          envs ||= {}
+          newenvs = envs.merge(Memory::NO_MEMORY_LEAK_ENVS) { |_, _, _| break }
+          envs = newenvs if newenvs
+        end
+        args.unshift(envs) if envs
+        cmd = [
+          'END {STDERR.puts '"#{token_dump}"'"FINAL=#{Memory::Status.new}"}',
+          prepare,
+          'STDERR.puts('"#{token_dump}"'"START=#{$initial_status = Memory::Status.new}")',
+          '$initial_size = $initial_status.size',
+          code,
+          'GC.start',
+        ].join("\n")
+        _, err, status = EnvUtil.invoke_ruby(args, cmd, true, true, **opt)
+        before = err.sub!(/^#{token_re}START=(\{.*\})\n/, '') && Memory::Status.parse($1)
+        after = err.sub!(/^#{token_re}FINAL=(\{.*\})\n/, '') && Memory::Status.parse($1)
+        assert(status.success?, FailDesc[status, message, err])
+        ([:size, (rss && :rss)] & after.members).each do |n|
+          b = before[n]
+          a = after[n]
+          next unless a > 0 and b > 0
+          assert_operator(a.fdiv(b), :<, limit, message(message) {"#{n}: #{b} => #{a}"})
+        end
+      rescue LoadError
+        skip
+      end
+
+      # kernel resolution can limit the minimum time we can measure
+      # [ruby-core:81540]
+      MIN_HZ = MiniTest::Unit::TestCase.windows? ? 67 : 100
+      MIN_MEASURABLE = 1.0 / MIN_HZ
+
+      def assert_cpu_usage_low(msg = nil, pct: 0.05, wait: 1.0, stop: nil)
+        require 'benchmark'
+
+        wait = EnvUtil.apply_timeout_scale(wait)
+        if wait < 0.1 # TIME_QUANTUM_USEC in thread_pthread.c
+          warn "test #{msg || 'assert_cpu_usage_low'} too short to be accurate"
+        end
+        tms = Benchmark.measure(msg || '') do
+          if stop
+            th = Thread.start {sleep wait; stop.call}
+            yield
+            th.join
+          else
+            begin
+              Timeout.timeout(wait) {yield}
+            rescue Timeout::Error
+            end
+          end
+        end
+
+        max = pct * tms.real
+        min_measurable = MIN_MEASURABLE
+        min_measurable *= 1.30 # add a little (30%) to account for misc. overheads
+        if max < min_measurable
+          max = min_measurable
+        end
+
+        assert_operator tms.total, :<=, max, msg
+      end
+
+      def assert_is_minus_zero(f)
+        assert(1.0/f == -Float::INFINITY, "#{f} is not -0.0")
+      end
+
+      def assert_file
+        AssertFile
+      end
+
+      # pattern_list is an array which contains regexp and :*.
+      # :* means any sequence.
+      #
+      # pattern_list is anchored.
+      # Use [:*, regexp, :*] for non-anchored match.
+      def assert_pattern_list(pattern_list, actual, message=nil)
+        rest = actual
+        anchored = true
+        pattern_list.each_with_index {|pattern, i|
+          if pattern == :*
+            anchored = false
+          else
+            if anchored
+              match = /\A#{pattern}/.match(rest)
+            else
+              match = pattern.match(rest)
+            end
+            unless match
+              msg = message(msg) {
+                expect_msg = "Expected #{mu_pp pattern}\n"
+                if /\n[^\n]/ =~ rest
+                  actual_mesg = +"to match\n"
+                  rest.scan(/.*\n+/) {
+                    actual_mesg << '  ' << $&.inspect << "+\n"
+                  }
+                  actual_mesg.sub!(/\+\n\z/, '')
+                else
+                  actual_mesg = "to match " + mu_pp(rest)
+                end
+                actual_mesg << "\nafter #{i} patterns with #{actual.length - rest.length} characters"
+                expect_msg + actual_mesg
+              }
+              assert false, msg
+            end
+            rest = match.post_match
+            anchored = true
+          end
+        }
+        if anchored
+          assert_equal("", rest)
+        end
+      end
+
+      # threads should respond to shift method.
+      # Array can be used.
+      def assert_join_threads(threads, message = nil)
+        errs = []
+        values = []
+        while th = threads.shift
+          begin
+            values << th.value
+          rescue Exception
+            errs << [th, $!]
+            th = nil
+          end
+        end
+        values
+      ensure
+        if th&.alive?
+          th.raise(Timeout::Error.new)
+          th.join rescue errs << [th, $!]
+        end
+        if !errs.empty?
+          msg = "exceptions on #{errs.length} threads:\n" +
+            errs.map {|t, err|
+            "#{t.inspect}:\n" +
+              err.full_message(highlight: false, order: :top)
+          }.join("\n---\n")
+          if message
+            msg = "#{message}\n#{msg}"
+          end
+          raise MiniTest::Assertion, msg
+        end
+      end
+
+      class << (AssertFile = Struct.new(:failure_message).new)
+        include Assertions
+        def assert_file_predicate(predicate, *args)
+          if /\Anot_/ =~ predicate
+            predicate = $'
+            neg = " not"
+          end
+          result = File.__send__(predicate, *args)
+          result = !result if neg
+          mesg = "Expected file ".dup << args.shift.inspect
+          mesg << "#{neg} to be #{predicate}"
+          mesg << mu_pp(args).sub(/\A\[(.*)\]\z/m, '(\1)') unless args.empty?
+          mesg << " #{failure_message}" if failure_message
+          assert(result, mesg)
+        end
+        alias method_missing assert_file_predicate
+
+        def for(message)
+          clone.tap {|a| a.failure_message = message}
+        end
+      end
+
+      class AllFailures
+        attr_reader :failures
+
+        def initialize
+          @count = 0
+          @failures = {}
+        end
+
+        def for(key)
+          @count += 1
+          yield
+        rescue Exception => e
+          @failures[key] = [@count, e]
+        end
+
+        def foreach(*keys)
+          keys.each do |key|
+            @count += 1
+            begin
+              yield key
+            rescue Exception => e
+              @failures[key] = [@count, e]
+            end
+          end
+        end
+
+        def message
+          i = 0
+          total = @count.to_s
+          fmt = "%#{total.size}d"
+          @failures.map {|k, (n, v)|
+            v = v.message
+            "\n#{i+=1}. [#{fmt%n}/#{total}] Assertion for #{k.inspect}\n#{v.b.gsub(/^/, '   | ').force_encoding(v.encoding)}"
+          }.join("\n")
+        end
+
+        def pass?
+          @failures.empty?
+        end
+      end
+
+      def assert_all_assertions(msg = nil)
+        all = AllFailures.new
+        yield all
+      ensure
+        assert(all.pass?, message(msg) {all.message.chomp(".")})
+      end
+      alias all_assertions assert_all_assertions
+
+      def assert_all_assertions_foreach(msg = nil, *keys, &block)
+        all = AllFailures.new
+        all.foreach(*keys, &block)
+      ensure
+        assert(all.pass?, message(msg) {all.message.chomp(".")})
+      end
+      alias all_assertions_foreach assert_all_assertions_foreach
+
+      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
+            ary = [msg.call, (default.call if default)].compact.reject(&:empty?)
+            if 1 < ary.length
+              ary[0...-1] = ary[0...-1].map {|str| str.sub(/(?<!\.)\z/, '.') }
+            end
+            begin
+              ary.join("\n")
+            rescue Encoding::CompatibilityError
+              ary.map(&:b).join("\n")
+            end
+          end
+        else
+          super
+        end
+      end
+    end
+  end
+end
diff --git a/tool/lib/test/unit/parallel.rb b/tool/lib/test/unit/parallel.rb
new file mode 100644
index 0000000000..d851326aca
--- /dev/null
+++ b/tool/lib/test/unit/parallel.rb
@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../.."
+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.readpartial(1024))
+              _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/ =~ $!.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 if orig_stdin
+        $stdout = orig_stdout if 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 File.realpath($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 || ['unknown method']
+            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:
+        @stdout.write(args.empty? ? "#{res}\n" : "#{res} #{args.pack("m0")}\n")
+      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
+
+      def record(suite, method, assertions, time, error) # :nodoc:
+        case error
+        when nil
+        when MiniTest::Assertion, MiniTest::Skip
+          case error.cause
+          when nil, MiniTest::Assertion, MiniTest::Skip
+          else
+            bt = error.backtrace
+            error = error.class.new(error.message)
+            error.set_backtrace(bt)
+          end
+        else
+          error = ProxyError.new(error)
+        end
+        _report "record", Marshal.dump([suite.name, method, assertions, time, error])
+        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/tool/lib/test/unit/testcase.rb b/tool/lib/test/unit/testcase.rb
new file mode 100644
index 0000000000..58cfbcab99
--- /dev/null
+++ b/tool/lib/test/unit/testcase.rb
@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+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)
+        super
+        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