RubyGems - paynow_sdk - Versions diffs - 0.2.0 → 1.0.0 - Mend

paynow_sdk 0.2.0 → 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2409) hide show

data/vendor/cache/ruby/2.7.0/gems/paynow_sdk-0.1.9/vendor/cache/ruby/2.7.0/gems/paynow_sdk-0.1.8/vendor/cache/ruby/2.7.0/gems/paynow_sdk-0.1.8/vendor/cache/ruby/2.7.0/gems/minitest-5.14.1/Rakefile DELETED

@@ -1,74 +0,0 @@
-# -*- ruby -*-
-require "rubygems"
-require "hoe"
-Hoe.plugin :seattlerb
-Hoe.plugin :rdoc
-Hoe.spec "minitest" do
-  developer "Ryan Davis", "ryand-ruby@zenspider.com"
-  license "MIT"
-  require_ruby_version "~> 2.2"
-end
-desc "Find missing expectations"
-task :specs do
-  $:.unshift "lib"
-  require "minitest/test"
-  require "minitest/spec"
-  pos_prefix, neg_prefix = "must", "wont"
-  skip_re = /^(must|wont)$|wont_(throw)|must_(block|not?_|nothing|send|raise$)/x
-  dont_flip_re = /(must|wont)_(include|respond_to)/
-  map = {
-    /(must_throw)s/                        => '\1',
-    /(?!not)_same/                         => "_be_same_as",
-    /_in_/                                 => "_be_within_",
-    /_operator/                            => "_be",
-    /_includes/                            => "_include",
-    /(must|wont)_(.*_of|nil|silent|empty)/ => '\1_be_\2',
-    /must_raises/                          => "must_raise",
-    /(must|wont)_predicate/                => '\1_be',
-    /(must|wont)_path_exists/              => 'path_\1_exist',
-  }
-  expectations = Minitest::Expectations.public_instance_methods.map(&:to_s)
-  assertions   = Minitest::Assertions.public_instance_methods.map(&:to_s)
-  assertions.sort.each do |assertion|
-    expectation = case assertion
-                  when /^assert/ then
-                    assertion.sub(/^assert/, pos_prefix.to_s)
-                  when /^refute/ then
-                    assertion.sub(/^refute/, neg_prefix.to_s)
-                  end
-    next unless expectation
-    next if expectation =~ skip_re
-    regexp, replacement = map.find { |re, _| expectation =~ re }
-    expectation.sub! regexp, replacement if replacement
-    next if expectations.include? expectation
-    args = [assertion, expectation].map(&:to_sym).map(&:inspect)
-    args << :reverse if expectation =~ dont_flip_re
-    puts
-    puts "##"
-    puts "# :method: #{expectation}"
-    puts "# See Minitest::Assertions##{assertion}"
-    puts
-    puts "infect_an_assertion #{args.join ", "}"
-  end
-end
-task :bugs do
-  sh "for f in bug*.rb ; do echo $f; echo; #{Gem.ruby} -Ilib $f && rm $f ; done"
-end
-# vim: syntax=Ruby

@@ -1,52 +0,0 @@
-# Specs:                               # Equivalent Unit Tests:
-###############################################################################
-describe Thingy do                     # class TestThingy < Minitest::Test
-  before do                            #   def setup
-    do_some_setup                      #     super
-  end                                  #     do_some_setup
-                                       #   end
-  it "should do the first thing" do    #
-    1.must_equal 1                     #   def test_first_thing
-  end                                  #     assert_equal 1, 1
-                                       #   end
-  describe SubThingy do                # end
-    before do                          #
-      do_more_setup                    # class TestSubThingy < TestThingy
-    end                                #   def setup
-                                       #     super
-    it "should do the second thing" do #     do_more_setup
-      2.must_equal 2                   #   end
-    end                                #
-  end                                  #   def test_second_thing
-end                                    #     assert_equal 2, 2
-                                       #   end
-                                       # end
-###############################################################################
-# runs 2 specs                         # runs 3 tests
-###############################################################################
-# The specs generate:
-class ThingySpec < Minitest::Spec
-  def setup
-    super
-    do_some_setup
-  end
-  def test_should_do_the_first_thing
-    assert_equal 1, 1
-  end
-end
-class SubThingySpec < ThingySpec
-  def setup
-    super
-    do_more_setup
-  end
-  # because only setup/teardown is inherited, not specs
-  remove_method :test_should_do_the_first_thing
-  def test_should_do_the_second_thing
-    assert_equal 2, 2
-  end
-end

@@ -1,32 +0,0 @@
-# :stopdoc:
-class Hoe
-end
-module Hoe::Minitest
-  def minitest?
-    self.name == "minitest"
-  end
-  def initialize_minitest
-    unless minitest? then
-      dir = "../../minitest/dev/lib"
-      Hoe.add_include_dirs dir if File.directory? dir
-    end
-    gem "minitest"
-    require "minitest"
-    version = Minitest::VERSION.split(/\./).first(2).join(".")
-    dependency "minitest", "~> #{version}", :development unless
-      minitest? or ENV["MT_NO_ISOLATE"]
-  end
-  def define_minitest_tasks
-    self.testlib = :minitest
-    # make sure we use the gemmed minitest on 1.9
-    self.test_prelude = 'gem "minitest"' unless
-      minitest? or ENV["MT_NO_ISOLATE"]
-  end
-end

@@ -1,1056 +0,0 @@
-require "optparse"
-require "thread"
-require "mutex_m"
-require "minitest/parallel"
-require "stringio"
-##
-# :include: README.rdoc
-module Minitest
-  VERSION = "5.14.1" # :nodoc:
-  ENCS = "".respond_to? :encoding # :nodoc:
-  @@installed_at_exit ||= false
-  @@after_run = []
-  @extensions = []
-  mc = (class << self; self; end)
-  ##
-  # Parallel test executor
-  mc.send :attr_accessor, :parallel_executor
-  warn "DEPRECATED: use MT_CPU instead of N for parallel test runs" if ENV["N"]
-  n_threads = (ENV["MT_CPU"] || ENV["N"] || 2).to_i
-  self.parallel_executor = Parallel::Executor.new n_threads
-  ##
-  # Filter object for backtraces.
-  mc.send :attr_accessor, :backtrace_filter
-  ##
-  # Reporter object to be used for all runs.
-  #
-  # NOTE: This accessor is only available during setup, not during runs.
-  mc.send :attr_accessor, :reporter
-  ##
-  # Names of known extension plugins.
-  mc.send :attr_accessor, :extensions
-  ##
-  # The signal to use for dumping information to STDERR. Defaults to "INFO".
-  mc.send :attr_accessor, :info_signal
-  self.info_signal = "INFO"
-  ##
-  # Registers Minitest to run at process exit
-  def self.autorun
-    at_exit {
-      next if $! and not ($!.kind_of? SystemExit and $!.success?)
-      exit_code = nil
-      pid = Process.pid
-      at_exit {
-        next if 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
-  def self.init_plugins options # :nodoc:
-    self.extensions.each do |name|
-      msg = "plugin_#{name}_init"
-      send msg, options if self.respond_to? msg
-    end
-  end
-  def self.load_plugins # :nodoc:
-    return unless self.extensions.empty?
-    seen = {}
-    require "rubygems" unless defined? Gem
-    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
-  ##
-  # 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.autorun
-  #     Minitest.run(args)
-  #       Minitest.__run(reporter, options)
-  #         Runnable.runnables.each
-  #           runnable.run(reporter, options)
-  #             self.runnable_methods.each
-  #               self.run_one_method(self, runnable_method, reporter)
-  #                 Minitest.run_one_method(klass, runnable_method)
-  #                   klass.new(runnable_method).run
-  def self.run args = []
-    self.load_plugins unless args.delete("--no-plugins") || ENV["MT_NO_PLUGINS"]
-    options = process_args args
-    reporter = CompositeReporter.new
-    reporter << SummaryReporter.new(options[:io], options)
-    reporter << ProgressReporter.new(options[:io], options)
-    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 reporter, options
-    rescue Interrupt
-      warn "Interrupted. Exiting..."
-    end
-    self.parallel_executor.shutdown
-    reporter.report
-    reporter.passed?
-  end
-  ##
-  # Internal run method. Responsible for telling all Runnable
-  # sub-classes to run.
-  def self.__run reporter, options
-    suites = Runnable.runnables.reject { |s| s.runnable_methods.empty? }.shuffle
-    parallel, serial = suites.partition { |s| s.test_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 reporter, options } +
-      parallel.map { |suite| suite.run reporter, options }
-  end
-  def self.process_args args = [] # :nodoc:
-    options = {
-               :io => $stdout,
-              }
-    orig_args = args.dup
-    OptionParser.new do |opts|
-      opts.banner  = "minitest options:"
-      opts.version = Minitest::VERSION
-      opts.on "-h", "--help", "Display this help." do
-        puts opts
-        exit
-      end
-      opts.on "--no-plugins", "Bypass minitest plugin auto-loading (or set $MT_NO_PLUGINS)."
-      desc = "Sets random seed. Also via env. Eg: SEED=n rake"
-      opts.on "-s", "--seed SEED", Integer, desc do |m|
-        options[:seed] = m.to_i
-      end
-      opts.on "-v", "--verbose", "Verbose. Show progress processing files." do
-        options[:verbose] = true
-      end
-      opts.on "-n", "--name PATTERN", "Filter run on /regexp/ or string." do |a|
-        options[:filter] = a
-      end
-      opts.on "-e", "--exclude PATTERN", "Exclude /regexp/ or string from run." do |a|
-        options[:exclude] = a
-      end
-      unless extensions.empty?
-        opts.separator ""
-        opts.separator "Known extensions: #{extensions.join(", ")}"
-        extensions.each do |meth|
-          msg = "plugin_#{meth}_options"
-          send msg, opts, options if self.respond_to?(msg)
-        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
-    srand options[:seed]
-    options[:args] = orig_args.map { |s|
-      s =~ /[\s|&<>$()]/ ? s.inspect : s
-    }.join " "
-    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
-    ##
-    # 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 self.run reporter, options = {}
-      filter = options[:filter] || "/./"
-      filter = Regexp.new $1 if filter.is_a?(String) && filter =~ %r%/(.*)/%
-      filtered_methods = self.runnable_methods.find_all { |m|
-        filter === m || filter === "#{self}##{m}"
-      }
-      exclude = options[:exclude]
-      exclude = Regexp.new $1 if exclude =~ %r%/(.*)/%
-      filtered_methods.delete_if { |m|
-        exclude === m || exclude === "#{self}##{m}"
-      }
-      return if filtered_methods.empty?
-      with_info_handler reporter do
-        filtered_methods.each do |method_name|
-          run_one_method 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 self.run_one_method klass, method_name, reporter
-      reporter.prerecord klass, method_name
-      reporter.record Minitest.run_one_method(klass, method_name)
-    end
-    def self.with_info_handler reporter, &block # :nodoc:
-      handler = lambda do
-        unless reporter.passed? then
-          warn "Current results:"
-          warn ""
-          warn reporter.reporters.first
-          warn ""
-        end
-      end
-      on_signal ::Minitest.info_signal, 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
-    @@marshal_dump_warned = false
-    def marshal_dump # :nodoc:
-      unless @@marshal_dump_warned then
-        warn ["Minitest::Runnable#marshal_dump is deprecated.",
-              "You might be violating internals. From", caller.first].join " "
-        @@marshal_dump_warned = true
-      end
-      [self.name, self.failures, self.assertions, self.time]
-    end
-    def marshal_load ary # :nodoc:
-      self.name, self.failures, self.assertions, self.time = ary
-    end
-    def failure # :nodoc:
-      self.failures.first
-    end
-    def initialize name # :nodoc:
-      self.name       = name
-      self.failures   = []
-      self.assertions = 0
-    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
-  ##
-  # 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
-    ##
-    # The location identifier of this test. Depends on a method
-    # existing called class_name.
-    def location
-      loc = " [#{self.failure.location}]" 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? { |f| UnexpectedError === f }
-    end
-  end
-  ##
-  # 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
-    undef_method :marshal_dump
-    undef_method :marshal_load
-    ##
-    # 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.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
-  ##
-  # Defines the API for Reporters. Subclass this and override whatever
-  # you want. Go nuts.
-  class AbstractReporter
-    include Mutex_m
-    ##
-    # 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
-  end
-  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:
-      if options[:verbose] then
-        io.print "%s#%s = " % [klass.name, name]
-        io.flush
-      end
-    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 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.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.skips      = aggregate[Skip].size
-    end
-  end
-  ##
-  # 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
-    # :stopdoc:
-    attr_accessor :sync
-    attr_accessor :old_sync
-    # :startdoc:
-    def start # :nodoc:
-      super
-      io.puts "Run options: #{options[:args]}"
-      io.puts
-      io.puts "# Running:"
-      io.puts
-      self.sync = io.respond_to? :"sync=" # stupid emacs
-      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]
-      filtered_results.each_with_index { |result, i|
-        io.puts "\n%3d) %s" % [i+1, result]
-      }
-      io.puts
-      io
-    end
-    def to_s # :nodoc:
-      aggregated_results(StringIO.new(binary_string)).string
-    end
-    def summary # :nodoc:
-      extra = ""
-      extra = "\n\nYou have skipped tests. Run with --verbose for details." if
-        results.any?(&:skipped?) unless options[:verbose] or ENV["MT_NO_SKIP_MSG"]
-      "%d runs, %d assertions, %d failures, %d errors, %d skips%s" %
-        [count, assertions, failures, errors, skips, extra]
-    end
-    private
-    if '<3'.respond_to? :b
-      def binary_string; ''.b; end
-    else
-      def binary_string; ''.force_encoding(Encoding::ASCII_8BIT); end
-    end
-  end
-  ##
-  # 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|
-        # TODO: remove conditional for minitest 6
-        reporter.prerecord klass, name if reporter.respond_to? :prerecord
-      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
-  ##
-  # Represents run failures.
-  class Assertion < Exception
-    def error # :nodoc:
-      self
-    end
-    ##
-    # Where was this run before an assertion was raised?
-    def location
-      last_before_assertion = ""
-      self.backtrace.reverse_each do |s|
-        break if s =~ /in .(assert|refute|flunk|pass|fail|raise|must|wont)/
-        last_before_assertion = s
-      end
-      last_before_assertion.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
-    # TODO: figure out how to use `cause` instead
-    attr_accessor :error # :nodoc:
-    def initialize error # :nodoc:
-      super "Unexpected exception"
-      self.error = error
-    end
-    def backtrace # :nodoc:
-      self.error.backtrace
-    end
-    def message # :nodoc:
-      bt = Minitest.filter_backtrace(self.backtrace).join "\n    "
-      "#{self.error.class}: #{self.error.message}\n    #{bt}"
-    end
-    def result_label # :nodoc:
-      "Error"
-    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 maglev?
-    def maglev? platform = defined?(RUBY_ENGINE) && RUBY_ENGINE
-      where = Minitest.filter_backtrace(caller).first
-      where = where.split(/:in /, 2).first # clean up noise
-      warn "DEPRECATED: `maglev?` called from #{where}. This will fail in Minitest 6."
-      "maglev" == platform
-    end
-    ##
-    # Is this running on mri?
-    def mri? platform = RUBY_DESCRIPTION
-      /^ruby/ =~ platform
-    end
-    ##
-    # Is this running on macOS?
-    def osx? platform = RUBY_PLATFORM
-      /darwin/ =~ platform
-    end
-    ##
-    # Is this running on rubinius?
-    def rubinius? platform = defined?(RUBY_ENGINE) && RUBY_ENGINE
-      where = Minitest.filter_backtrace(caller).first
-      where = where.split(/:in /, 2).first # clean up noise
-      warn "DEPRECATED: `rubinius?` called from #{where}. This will fail in Minitest 6."
-      "rbx" == platform
-    end
-    ##
-    # Is this running on windows?
-    def windows? platform = RUBY_PLATFORM
-      /mswin|mingw/ =~ platform
-    end
-  end
-  ##
-  # The standard backtrace filter for minitest.
-  #
-  # See Minitest.backtrace_filter=.
-  class BacktraceFilter
-    MT_RE = %r%lib/minitest% #:nodoc:
-    ##
-    # 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| line !~ MT_RE }
-      new_bt = bt.select     { |line| line !~ MT_RE } if new_bt.empty?
-      new_bt = bt.dup                                 if new_bt.empty?
-      new_bt
-    end
-  end
-  self.backtrace_filter = BacktraceFilter.new
-  def self.run_one_method klass, method_name # :nodoc:
-    result = klass.new(method_name).run
-    raise "#{klass}#run _must_ return a Result" unless Result === result
-    result
-  end
-  # :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 "minitest/test"