localizable_model 0.6.7 → 0.6.8

data/vendor/bundle/ruby/4.0.0/gems/minitest-6.0.5/lib/minitest.rb

@@ -1,1232 +0,0 @@
-require "optparse"
-require "stringio"
-require "etc"
-
-require_relative "minitest/parallel"
-require_relative "minitest/compress"
-
-##
-# The top-level namespace for Minitest. Also the location of the main
-# runtime. See +Minitest.run+ for more information.
-
-module Minitest
-  VERSION = "6.0.4" # :nodoc:
-
-  @@installed_at_exit ||= false
-  @@after_run = []
-  @extensions = []
-
-  def self.cattr_accessor name # :nodoc:
-    (class << self; self; end).attr_accessor name
-  end
-
-  ##
-  # The random seed used for this run. This is used to srand at the
-  # start of the run and between each +Runnable.run+.
-  #
-  # Set via Minitest.run after processing args.
-
-  cattr_accessor :seed
-
-  ##
-  # Parallel test executor
-
-  cattr_accessor :parallel_executor
-
-  n_threads = (ENV["MT_CPU"] || Etc.nprocessors).to_i
-
-  self.parallel_executor = Parallel::Executor.new n_threads if n_threads > 1
-
-  ##
-  # Filter object for backtraces.
-
-  cattr_accessor :backtrace_filter
-
-  ##
-  # Reporter object to be used for all runs.
-  #
-  # NOTE: This accessor is only available during setup, not during runs.
-
-  cattr_accessor :reporter
-
-  ##
-  # Names of known extension plugins.
-
-  cattr_accessor :extensions
-
-  ##
-  # The signal to use for dumping information to STDERR. Defaults to "INFO".
-
-  cattr_accessor :info_signal
-  self.info_signal = "INFO"
-
-  cattr_accessor :allow_fork
-  self.allow_fork = false
-
-  ##
-  # Registers Minitest to run at process exit
-
-  def self.autorun
-    Warning[:deprecated] = true
-
-    at_exit {
-      next if $! and not ($!.kind_of? SystemExit and $!.success?)
-
-      exit_code = nil
-
-      pid = Process.pid
-      at_exit {
-        next if !Minitest.allow_fork && Process.pid != pid
-        @@after_run.reverse_each(&:call)
-        exit exit_code || false
-      }
-
-      exit_code = Minitest.run ARGV
-    } unless @@installed_at_exit
-    @@installed_at_exit = true
-  end
-
-  ##
-  # A simple hook allowing you to run a block of code after everything
-  # is done running. Eg:
-  #
-  #   Minitest.after_run { p $debugging_info }
-
-  def self.after_run &block
-    @@after_run << block
-  end
-
-  ##
-  # Manually load plugins by name.
-
-  def self.load *names
-    names.each do |name|
-      require "minitest/#{name}_plugin"
-
-      self.extensions << name.to_s
-    end
-  end
-
-  ##
-  # Register a plugin to be used. Does NOT require / load it.
-
-  def self.register_plugin name_or_mod
-    self.extensions << name_or_mod
-    nil
-  end
-
-  def self.load_plugins # :nodoc:
-    return unless defined? Gem
-
-    seen = {}
-
-    Gem.find_files("minitest/*_plugin.rb").each do |plugin_path|
-      name = File.basename plugin_path, "_plugin.rb"
-
-      next if seen[name]
-      seen[name] = true
-
-      require plugin_path
-      self.extensions << name
-    end
-  end
-
-  def self.init_plugins options # :nodoc:
-    self.extensions.each do |mod_or_meth|
-      case mod_or_meth
-      when Symbol, String then
-        name = mod_or_meth
-        msg = "plugin_#{name}_init"
-        next unless self.respond_to? msg
-        send msg, options
-      when Module then
-        recv = mod_or_meth
-        next unless recv.respond_to? :minitest_plugin_init
-        recv.minitest_plugin_init options
-      else
-        raise ArgumentError, "plugin is %p, but it must be a symbol, string or module" % [mod_or_meth]
-      end
-    end
-  end
-
-  def self.process_args args = [] # :nodoc:
-    options = {
-                :io => $stdout,
-              }
-    orig_args = args.dup
-
-    warn "--no-plugins is a no-op" if args.delete "--no-plugins" # TODO: remove me! when?
-
-    OptionParser.new do |opts|
-      opts.program_name = "minitest"
-      opts.version = Minitest::VERSION
-
-      opts.banner = [
-        "Usage: minitest [paths]     [options]",
-        "ruby path/to/test.rb [options]",
-        "rake test          [A=options] (see Minitest::TestTask for more options)\n\n",
-      ].join "\n   or: "
-
-      opts.on "-h", "--help", "Display this help." do
-        puts opts
-        exit! true
-      end
-
-      opts.on "-V", "--version", "Display the version." do
-        puts "#{opts.program_name} #{Minitest::VERSION}"
-        exit! true
-      end
-
-      desc = "Sets random seed. Also via env, eg: SEED=42"
-      opts.on "-s", "--seed SEED", Integer, desc do |m|
-        options[:seed] = m
-      end
-
-      opts.on "-v", "--verbose", "Verbose. Print each name as they run." do
-        options[:verbose] = true
-      end
-
-      opts.on "-q", "--quiet", "Quiet. Show no dots while processing files." do
-        options[:quiet] = true
-      end
-
-      opts.on "--show-skips", "Show skipped at the end of run." do
-        options[:show_skips] = true
-      end
-
-      opts.on "-b", "--bisect", "Run minitest in bisect-mode to isolate flaky tests." if
-        File.basename($0).match?(/minitest/)
-
-      opts.on "-i", "--include PATTERN", "Include /regexp/ or string for run." do |a|
-        options[:include] = a
-      end
-
-      opts.on "-e", "--exclude PATTERN", "Exclude /regexp/ or string from run." do |a|
-        options[:exclude] = a
-      end
-
-      # part of my unofficial embedded gem "makeoptparseworkwell"
-      def opts.topdict(name)   = (name.length > 1 ? top.long : top.short)
-      def opts.alias(from, to) = (dict = topdict(from) ; dict[to] = dict[from])
-
-      # these will work but won't show up in --help output:
-      opts.alias "include", "name"
-      opts.alias "i",       "n"
-      opts.alias "e",       "x"
-
-      opts.on "-S", "--skip CODES", String, "Skip reporting of certain types of results (eg E)." do |s|
-        options[:skip] = s.chars.to_a
-      end
-
-      opts.on "-W[error]", String, "Turn Ruby warnings into errors" do |s|
-        options[:Werror] = true
-        case s
-        when "error", "all", nil then
-          require_relative "minitest/error_on_warning"
-          $VERBOSE = true
-          ::Warning[:deprecated] = true
-        else
-          ::Warning[s.to_sym] = true # check validity of category
-        end
-      end
-
-      unless extensions.empty?
-        opts.separator ""
-        opts.separator "Known extensions: #{extensions.join ", "}"
-
-        extensions.each do |mod_or_meth|
-          case mod_or_meth
-          when Symbol, String then
-            meth = mod_or_meth
-            msg = "plugin_#{meth}_options"
-            send msg, opts, options if respond_to? msg
-          when Module
-            recv = mod_or_meth
-            next unless recv.respond_to? :minitest_plugin_options
-            recv.minitest_plugin_options opts, options
-          else
-            raise ArgumentError, "plugin is %p, but it must be a symbol, string or module" % [mod_or_meth]
-          end
-        end
-      end
-
-      begin
-        opts.parse! args
-      rescue OptionParser::InvalidOption => e
-        puts
-        puts e
-        puts
-        puts opts
-        exit 1
-      end
-
-      orig_args -= args
-    end
-
-    unless options[:seed] then
-      srand
-      options[:seed] = (ENV["SEED"] || srand).to_i % 0xFFFF
-      orig_args << "--seed" << options[:seed].to_s
-    end
-
-    options[:args] = orig_args.map { |s|
-      s.match?(/[\s|&<>$()]/) ? s.inspect : s
-    }.join " "
-
-    options
-  end
-
-  ##
-  # This is the top-level run method. Everything starts from here. It
-  # tells each Runnable sub-class to run, and each of those are
-  # responsible for doing whatever they do.
-  #
-  # The overall structure of a run looks like this:
-  #
-  #   [Minitest.load_plugins] optional, called by user, or require what you want
-  #   Minitest.autorun
-  #     Minitest.run(args)
-  #       Minitest.process_args
-  #       Minitest.init_plugins
-  #       Minitest.run_all_suites(reporter, options)
-  #         Runnable.runnables.each |runnable_klass|
-  #           runnable_klass.run_suite(reporter, options)
-  #             filtered_methods = runnable_klass.filter_runnable_methods options
-  #             filtered_methods.each |runnable_method|
-  #               runnable_klass.run(self, runnable_method, reporter)
-  #                 runnable_klass.new(runnable_method).run
-
-  def self.run args = []
-    options = process_args args
-
-    Minitest.seed = options[:seed]
-    srand Minitest.seed
-
-    reporter = CompositeReporter.new
-    reporter << SummaryReporter.new(options[:io], options)
-    reporter << ProgressReporter.new(options[:io], options) unless options[:quiet]
-
-    self.reporter = reporter # this makes it available to plugins
-    self.init_plugins options
-    self.reporter = nil # runnables shouldn't depend on the reporter, ever
-
-    self.parallel_executor.start if parallel_executor.respond_to? :start
-    reporter.start
-    begin
-      run_all_suites reporter, options
-      finished = true
-    rescue Interrupt
-      warn "Interrupted. Exiting..."
-    end
-    self.parallel_executor.shutdown if parallel_executor.respond_to? :shutdown
-
-    # might have been removed/replaced during init_plugins:
-    summary = reporter.reporters.grep(SummaryReporter).first
-
-    reporter.report
-
-    return empty_run! options if finished && summary && summary.count == 0
-    finished and reporter.passed?
-  end
-
-  def self.empty_run! options # :nodoc:
-    filter = options[:include]
-    return true unless filter # no filter, but nothing ran == success
-
-    warn "Nothing ran for filter: %s" % [filter]
-
-    require "did_you_mean" # soft dependency, punt if it doesn't load
-
-    ms = Runnable.runnables.flat_map(&:runnable_methods)
-    cs = DidYouMean::SpellChecker.new(dictionary: ms).correct filter
-
-    warn DidYouMean::Formatter.message_for cs unless cs.empty?
-  rescue LoadError
-    # do nothing
-  end
-
-  ##
-  # Internal run method. Responsible for telling all Runnable
-  # sub-classes to run.
-
-  def self.run_all_suites reporter, options
-    suites = Runnable.runnables.shuffle
-    parallel, serial = suites.partition { |s| s.run_order == :parallel }
-
-    # If we run the parallel tests before the serial tests, the parallel tests
-    # could run in parallel with the serial tests. This would be bad because
-    # the serial tests won't lock around Reporter#record. Run the serial tests
-    # first, so that after they complete, the parallel tests will lock when
-    # recording results.
-    serial.map { |suite| suite.run_suite reporter, options } +
-      parallel.map { |suite| suite.run_suite reporter, options }
-  end
-
-  def self.filter_backtrace bt # :nodoc:
-    result = backtrace_filter.filter bt
-    result = bt.dup if result.empty?
-    result
-  end
-
-  ##
-  # Represents anything "runnable", like Test, Spec, Benchmark, or
-  # whatever you can dream up.
-  #
-  # Subclasses of this are automatically registered and available in
-  # Runnable.runnables.
-
-  class Runnable
-    ##
-    # Number of assertions executed in this run.
-
-    attr_accessor :assertions
-
-    ##
-    # An assertion raised during the run, if any.
-
-    attr_accessor :failures
-
-    ##
-    # The time it took to run.
-
-    attr_accessor :time
-
-    def time_it # :nodoc:
-      t0 = Minitest.clock_time
-
-      yield
-    ensure
-      self.time = Minitest.clock_time - t0
-    end
-
-    ##
-    # Name of the run.
-
-    def name
-      @NAME
-    end
-
-    ##
-    # Set the name of the run.
-
-    def name= o
-      @NAME = o
-    end
-
-    ##
-    # Returns all instance methods matching the pattern +re+.
-
-    def self.methods_matching re
-      public_instance_methods(true).grep(re).map(&:to_s)
-    end
-
-    def self.reset # :nodoc:
-      @@runnables = []
-    end
-
-    reset
-
-    ##
-    # Returns an array of filtered +runnable_methods+. Uses
-    # options[:include] (--include arguments) and options[:exclude]
-    # (--exclude arguments) values to filter.
-
-    def self.filter_runnable_methods options={}
-      pos = options[:include]
-      neg = options[:exclude]
-
-      pos = Regexp.new $1 if pos.kind_of?(String) && pos =~ %r%/(.*)/%
-      neg = Regexp.new $1 if neg.kind_of?(String) && neg =~ %r%/(.*)/%
-
-      # at most 1-2% slower than a 1-pass version, stop optimizing this
-      self.runnable_methods
-        .select { |m| !pos ||  pos === m || pos === "#{self}##{m}"  }
-        .reject { |m|  neg && (neg === m || neg === "#{self}##{m}") }
-    end
-
-    ##
-    # Responsible for running all runnable methods in a given class,
-    # each in its own instance. Each instance is passed to the
-    # reporter to record.
-
-    def Runnable.run_suite reporter, options = {}
-      filtered_methods = filter_runnable_methods options
-
-      return if filtered_methods.empty?
-
-      t0 = name = nil
-
-      @_info_handler = lambda do
-        unless reporter.passed? then
-          warn "Current results:"
-          warn reporter.reporters.grep(SummaryReporter).first
-        end
-
-        warn "Current: %s#%s %.2fs" % [self, name, Minitest.clock_time - t0]
-      end
-
-      with_info_handler do
-        filtered_methods.each do |method_name|
-          name = method_name
-          t0 = Minitest.clock_time
-
-          run self, method_name, reporter
-        end
-      end
-    end
-
-    ##
-    # Runs a single method and has the reporter record the result.
-    # This was considered internal API but is factored out of run so
-    # that subclasses can specialize the running of an individual
-    # test. See Minitest::ParallelTest::ClassMethods for an example.
-
-    def Runnable.run klass, method_name, reporter
-      reporter.prerecord klass, method_name
-      reporter.record klass.new(method_name).run
-    end
-
-    ##
-    # Defines the order to run tests (:random by default). Override
-    # this or use a convenience method to change it for your tests.
-
-    def self.run_order
-      :random
-    end
-
-    def self.with_info_handler _reporter=nil, &block # :nodoc:
-      on_signal ::Minitest.info_signal, @_info_handler, &block
-    end
-
-    SIGNALS = Signal.list # :nodoc:
-
-    def self.on_signal name, action # :nodoc:
-      supported = SIGNALS[name]
-
-      old_trap = trap name do
-        old_trap.call if old_trap.respond_to? :call
-        action.call
-      end if supported
-
-      yield
-    ensure
-      trap name, old_trap if supported
-    end
-
-    ##
-    # Each subclass of Runnable is responsible for overriding this
-    # method to return all runnable methods. See #methods_matching.
-
-    def self.runnable_methods
-      raise NotImplementedError, "subclass responsibility"
-    end
-
-    ##
-    # Returns all subclasses of Runnable.
-
-    def self.runnables
-      @@runnables
-    end
-
-    def failure # :nodoc:
-      self.failures.first
-    end
-
-    def initialize name # :nodoc:
-      self.name       = name
-      self.failures   = []
-      self.assertions = 0
-      # lazy initializer for metadata
-    end
-
-    ##
-    # Metadata you attach to the test results that get sent to the reporter.
-    #
-    # Lazily initializes to a hash, to keep memory down.
-    #
-    # NOTE: this data *must* be plain (read: marshal-able) data!
-    # Hashes! Arrays! Strings!
-
-    def metadata
-      @metadata ||= {}
-    end
-
-    ##
-    # Sets metadata, mainly used for +Result.from+.
-
-    attr_writer :metadata
-
-    ##
-    # Returns true if metadata exists.
-
-    def metadata?
-      defined? @metadata
-    end
-
-    ##
-    # Runs a single method. Needs to return self.
-
-    def run
-      raise NotImplementedError, "subclass responsibility"
-    end
-
-    ##
-    # Did this run pass?
-    #
-    # Note: skipped runs are not considered passing, but they don't
-    # cause the process to exit non-zero.
-
-    def passed?
-      raise NotImplementedError, "subclass responsibility"
-    end
-
-    ##
-    # Returns a single character string to print based on the result
-    # of the run. One of <tt>"."</tt>, <tt>"F"</tt>,
-    # <tt>"E"</tt> or <tt>"S"</tt>.
-
-    def result_code
-      raise NotImplementedError, "subclass responsibility"
-    end
-
-    ##
-    # Was this run skipped? See #passed? for more information.
-
-    def skipped?
-      raise NotImplementedError, "subclass responsibility"
-    end
-  end # Runnable
-
-  ##
-  # Shared code for anything that can get passed to a Reporter. See
-  # Minitest::Test & Minitest::Result.
-
-  module Reportable
-    ##
-    # Did this run pass?
-    #
-    # Note: skipped runs are not considered passing, but they don't
-    # cause the process to exit non-zero.
-
-    def passed?
-      not self.failure
-    end
-
-    BASE_DIR = "#{Dir.pwd}/" # :nodoc:
-
-    ##
-    # The location identifier of this test. Depends on a method
-    # existing called class_name.
-
-    def location
-      loc = " [#{self.failure.location.delete_prefix BASE_DIR}]" unless passed? or error?
-      "#{self.class_name}##{self.name}#{loc}"
-    end
-
-    def class_name # :nodoc:
-      raise NotImplementedError, "subclass responsibility"
-    end
-
-    ##
-    # Returns ".", "F", or "E" based on the result of the run.
-
-    def result_code
-      self.failure and self.failure.result_code or "."
-    end
-
-    ##
-    # Was this run skipped?
-
-    def skipped?
-      self.failure and Skip === self.failure
-    end
-
-    ##
-    # Did this run error?
-
-    def error?
-      self.failures.any? UnexpectedError
-    end
-  end # Reportable
-
-  ##
-  # This represents a test result in a clean way that can be
-  # marshalled over a wire. Tests can do anything they want to the
-  # test instance and can create conditions that cause Marshal.dump to
-  # blow up. By using Result.from(a_test) you can be reasonably sure
-  # that the test result can be marshalled.
-
-  class Result < Runnable
-    include Minitest::Reportable
-
-    ##
-    # The class name of the test result.
-
-    attr_accessor :klass
-
-    ##
-    # The location of the test method.
-
-    attr_accessor :source_location
-
-    ##
-    # Create a new test result from a Runnable instance.
-
-    def self.from runnable
-      o = runnable
-
-      r = self.new o.name
-      r.klass      = o.class.name
-      r.assertions = o.assertions
-      r.failures   = o.failures.dup
-      r.time       = o.time
-      r.metadata   = o.metadata if o.metadata?
-
-      r.source_location = o.method(o.name).source_location rescue ["unknown", -1]
-
-      r
-    end
-
-    def class_name # :nodoc:
-      self.klass # for Minitest::Reportable
-    end
-
-    def to_s # :nodoc:
-      return location if passed? and not skipped?
-
-      failures.map { |failure|
-        "#{failure.result_label}:\n#{self.location}:\n#{failure.message}\n"
-      }.join "\n"
-    end
-  end # Result
-
-  ##
-  # Defines the API for Reporters. Subclass this and override whatever
-  # you want. Go nuts.
-
-  class AbstractReporter
-
-    def initialize # :nodoc:
-      @mutex = Mutex.new
-    end
-
-    ##
-    # Starts reporting on the run.
-
-    def start
-    end
-
-    ##
-    # About to start running a test. This allows a reporter to show
-    # that it is starting or that we are in the middle of a test run.
-
-    def prerecord klass, name
-    end
-
-    ##
-    # Output and record the result of the test. Call
-    # {result#result_code}[rdoc-ref:Runnable#result_code] to get the
-    # result character string. Stores the result of the run if the run
-    # did not pass.
-
-    def record result
-    end
-
-    ##
-    # Outputs the summary of the run.
-
-    def report
-    end
-
-    ##
-    # Did this run pass?
-
-    def passed?
-      true
-    end
-
-    def synchronize &block # :nodoc:
-      @mutex.synchronize(&block)
-    end
-  end # AbstractReportera
-
-  class Reporter < AbstractReporter # :nodoc:
-    ##
-    # The IO used to report.
-
-    attr_accessor :io
-
-    ##
-    # Command-line options for this run.
-
-    attr_accessor :options
-
-    def initialize io = $stdout, options = {} # :nodoc:
-      super()
-      self.io      = io
-      self.options = options
-    end
-  end
-
-  ##
-  # A very simple reporter that prints the "dots" during the run.
-  #
-  # This is added to the top-level CompositeReporter at the start of
-  # the run. If you want to change the output of minitest via a
-  # plugin, pull this out of the composite and replace it with your
-  # own.
-
-  class ProgressReporter < Reporter
-    def prerecord klass, name # :nodoc:
-      return unless options[:verbose]
-
-      io.print "%s#%s = " % [klass.name, name]
-      io.flush
-    end
-
-    def record result # :nodoc:
-      io.print "%.2f s = " % [result.time] if options[:verbose]
-      io.print result.result_code
-      io.puts if options[:verbose]
-    end
-  end
-
-  ##
-  # A reporter that gathers statistics about a test run. Does not do
-  # any IO because meant to be used as a parent class for a reporter
-  # that does.
-  #
-  # If you want to create an entirely different type of output (eg,
-  # CI, HTML, etc), this is the place to start.
-  #
-  # Example:
-  #
-  #   class JenkinsCIReporter < StatisticsReporter
-  #     def report
-  #       super  # Needed to calculate some statistics
-  #
-  #       print "<testsuite "
-  #       print "tests='#{count}' "
-  #       print "failures='#{failures}' "
-  #       # Remaining XML...
-  #     end
-  #   end
-
-  class StatisticsReporter < Reporter
-    ##
-    # Total number of assertions.
-
-    attr_accessor :assertions
-
-    ##
-    # Total number of test cases.
-
-    attr_accessor :count
-
-    ##
-    # An +Array+ of test cases that failed or were skipped.
-
-    attr_accessor :results
-
-    ##
-    # Time the test run started. If available, the monotonic clock is
-    # used and this is a +Float+, otherwise it's an instance of
-    # +Time+.
-
-    attr_accessor :start_time
-
-    ##
-    # Test run time. If available, the monotonic clock is used and
-    # this is a +Float+, otherwise it's an instance of +Time+.
-
-    attr_accessor :total_time
-
-    ##
-    # Total number of tests that failed.
-
-    attr_accessor :failures
-
-    ##
-    # Total number of tests that erred.
-
-    attr_accessor :errors
-
-    ##
-    # Total number of tests that warned.
-
-    attr_accessor :warnings
-
-    ##
-    # Total number of tests that where skipped.
-
-    attr_accessor :skips
-
-    def initialize io = $stdout, options = {} # :nodoc:
-      super
-
-      self.assertions = 0
-      self.count      = 0
-      self.results    = []
-      self.start_time = nil
-      self.total_time = nil
-      self.failures   = nil
-      self.errors     = nil
-      self.warnings   = nil
-      self.skips      = nil
-    end
-
-    def passed? # :nodoc:
-      results.all?(&:skipped?)
-    end
-
-    def start # :nodoc:
-      self.start_time = Minitest.clock_time
-    end
-
-    def record result # :nodoc:
-      self.count += 1
-      self.assertions += result.assertions
-
-      results << result if not result.passed? or result.skipped?
-    end
-
-    ##
-    # Report on the tracked statistics.
-
-    def report
-      aggregate = results.group_by { |r| r.failure.class }
-      aggregate.default = [] # dumb. group_by should provide this
-
-      self.total_time = Minitest.clock_time - start_time
-      self.failures   = aggregate[Assertion].size
-      self.errors     = aggregate[UnexpectedError].size
-      self.warnings   = aggregate[UnexpectedWarning].size
-      self.skips      = aggregate[Skip].size
-    end
-  end # StatisticsReporter
-
-  ##
-  # A reporter that prints the header, summary, and failure details at
-  # the end of the run.
-  #
-  # This is added to the top-level CompositeReporter at the start of
-  # the run. If you want to change the output of minitest via a
-  # plugin, pull this out of the composite and replace it with your
-  # own.
-
-  class SummaryReporter < StatisticsReporter
-    attr_accessor :sync     # :nodoc:
-    attr_accessor :old_sync # :nodoc:
-
-    def start # :nodoc:
-      super
-
-      io.puts "Run options: #{options[:args]}"
-      io.puts
-      io.puts "# Running:"
-      io.puts
-
-      self.sync = io.respond_to? :"sync="
-      self.old_sync, io.sync = io.sync, true if self.sync
-    end
-
-    def report # :nodoc:
-      super
-
-      io.sync = self.old_sync
-
-      io.puts unless options[:verbose] # finish the dots
-      io.puts
-      io.puts statistics
-      aggregated_results io
-      io.puts summary
-    end
-
-    def statistics # :nodoc:
-      "Finished in %.6fs, %.4f runs/s, %.4f assertions/s." %
-        [total_time, count / total_time, assertions / total_time]
-    end
-
-    def aggregated_results io # :nodoc:
-      filtered_results = results.dup
-      filtered_results.reject!(&:skipped?) unless
-        options[:verbose] or options[:show_skips]
-
-      skip = options[:skip] || []
-
-      filtered_results.each_with_index { |result, i|
-        next if skip.include? result.result_code
-
-        io.puts "\n%3d) %s" % [i+1, result]
-      }
-      io.puts
-      io
-    end
-
-    def to_s # :nodoc:
-      aggregated_results(StringIO.new("".b)).string
-    end
-
-    def summary # :nodoc:
-      extra = []
-
-      extra << ", %d warnings" % [warnings] if options[:Werror]
-
-      extra << "\n\nYou have skipped tests. Run with --verbose for details." if
-        results.any?(&:skipped?) unless
-        options[:verbose]        or
-        options[:show_skips]     or
-        ENV["MT_NO_SKIP_MSG"]
-
-      "%d runs, %d assertions, %d failures, %d errors, %d skips%s" %
-        [count, assertions, failures, errors, skips, extra.join]
-    end
-  end # SummaryReporter
-
-  ##
-  # Dispatch to multiple reporters as one.
-
-  class CompositeReporter < AbstractReporter
-    ##
-    # The list of reporters to dispatch to.
-
-    attr_accessor :reporters
-
-    def initialize *reporters # :nodoc:
-      super()
-      self.reporters = reporters
-    end
-
-    def io # :nodoc:
-      reporters.first.io
-    end
-
-    ##
-    # Add another reporter to the mix.
-
-    def << reporter
-      self.reporters << reporter
-    end
-
-    def passed? # :nodoc:
-      self.reporters.all?(&:passed?)
-    end
-
-    def start # :nodoc:
-      self.reporters.each(&:start)
-    end
-
-    def prerecord klass, name # :nodoc:
-      self.reporters.each do |reporter|
-        reporter.prerecord klass, name
-      end
-    end
-
-    def record result # :nodoc:
-      self.reporters.each do |reporter|
-        reporter.record result
-      end
-    end
-
-    def report # :nodoc:
-      self.reporters.each(&:report)
-    end
-  end # CompositeReporter
-
-  ##
-  # Represents run failures.
-
-  class Assertion < Exception
-    RE = /in [`'](?:[^']+[#.])?(?:assert|refute|flunk|pass|fail|raise|must|wont)/ # :nodoc:
-
-    def error # :nodoc:
-      self
-    end
-
-    ##
-    # Where was this run before an assertion was raised?
-
-    def location
-      bt  = Minitest.filter_backtrace self.backtrace
-      idx = bt.rindex { |s| s.match? RE } || -1 # fall back to first item
-      loc = bt[idx+1] || bt.last || "unknown:-1"
-
-      loc.sub(/:in .*$/, "")
-    end
-
-    def result_code # :nodoc:
-      result_label[0, 1]
-    end
-
-    def result_label # :nodoc:
-      "Failure"
-    end
-  end
-
-  ##
-  # Assertion raised when skipping a run.
-
-  class Skip < Assertion
-    def result_label # :nodoc:
-      "Skipped"
-    end
-  end
-
-  ##
-  # Assertion wrapping an unexpected error that was raised during a run.
-
-  class UnexpectedError < Assertion
-    include Minitest::Compress
-
-    # TODO: figure out how to use `cause` instead
-    attr_accessor :error # :nodoc:
-
-    def initialize error # :nodoc:
-      super "Unexpected exception"
-
-      if SystemStackError === error then
-        bt = error.backtrace
-        new_bt = compress bt
-        error = error.exception "#{bt.size} -> #{new_bt.size}"
-        error.set_backtrace new_bt
-      end
-
-      self.error = error
-    end
-
-    def backtrace # :nodoc:
-      self.error.backtrace
-    end
-
-    BASE_RE = %r%#{Regexp.escape Dir.pwd}/% # :nodoc:
-
-    def message # :nodoc:
-      bt = Minitest.filter_backtrace(self.backtrace).join("\n    ")
-        .gsub(BASE_RE, "")
-      "#{self.error.class}: #{self.error.message}\n    #{bt}"
-    end
-
-    def result_label # :nodoc:
-      "Error"
-    end
-  end
-
-  ##
-  # Assertion raised on warning when running in -Werror mode.
-
-  class UnexpectedWarning < Assertion
-    def result_label # :nodoc:
-      "Warning"
-    end
-  end
-
-  ##
-  # Provides a simple set of guards that you can use in your tests
-  # to skip execution if it is not applicable. These methods are
-  # mixed into Test as both instance and class methods so you
-  # can use them inside or outside of the test methods.
-  #
-  #   def test_something_for_mri
-  #     skip "bug 1234"  if jruby?
-  #     # ...
-  #   end
-  #
-  #   if windows? then
-  #     # ... lots of test methods ...
-  #   end
-
-  module Guard
-
-    ##
-    # Is this running on jruby?
-
-    def jruby? platform = RUBY_PLATFORM
-      "java" == platform
-    end
-
-    ##
-    # Is this running on mri?
-
-    def mri? platform = RUBY_DESCRIPTION
-      platform.start_with? "ruby"
-    end
-
-    ##
-    # Is this running on macOS?
-
-    def osx? platform = RUBY_PLATFORM
-      platform.include? "darwin"
-    end
-
-    ##
-    # Is this running on windows?
-
-    def windows? platform = RUBY_PLATFORM
-      /mswin|mingw/.match? platform
-    end
-  end
-
-  ##
-  # The standard backtrace filter for minitest.
-  #
-  # See Minitest.backtrace_filter=.
-
-  class BacktraceFilter
-
-    MT_RE = %r%lib/minitest|internal:warning% # :nodoc:
-
-    ##
-    # The regular expression to use to filter backtraces. Defaults to +MT_RE+.
-
-    attr_accessor :regexp
-
-    def initialize regexp = MT_RE # :nodoc:
-      self.regexp = regexp
-    end
-
-    ##
-    # Filter +bt+ to something useful. Returns the whole thing if
-    # $DEBUG (ruby) or $MT_DEBUG (env).
-
-    def filter bt
-      return ["No backtrace"] unless bt
-
-      return bt.dup if $DEBUG || ENV["MT_DEBUG"]
-
-      new_bt = bt.take_while { |line| !regexp.match? line.to_s }
-      new_bt = bt.select     { |line| !regexp.match? line.to_s } if new_bt.empty?
-      new_bt = bt.dup                                            if new_bt.empty?
-
-      new_bt
-    end
-  end
-
-  self.backtrace_filter = BacktraceFilter.new
-
-  # :stopdoc:
-
-  if defined? Process::CLOCK_MONOTONIC # :nodoc:
-    def self.clock_time
-      Process.clock_gettime Process::CLOCK_MONOTONIC
-    end
-  else
-    def self.clock_time
-      Time.now
-    end
-  end
-
-  class Runnable # re-open
-    def self.inherited klass # :nodoc:
-      self.runnables << klass
-      super
-    end
-  end
-
-  # :startdoc:
-end
-
-require_relative "minitest/test"
-if ENV["MINITEST_SERVER"] then
-  require_relative "minitest/server_plugin"
-  Minitest.register_plugin :server
-end