RubyGems - lazy_record - Versions diffs - 0.2.1 → 0.2.2 - Mend

lazy_record 0.2.1 → 0.2.2

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 (1338) hide show

data/vendor/bundle/gems/minitest-5.10.1/Rakefile DELETED Viewed

@@ -1,86 +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"
-  ## TODO: uncomment this on the last point release on 5.x
-  #
-  #   self.post_install_message = <<-"EOM"
-  # NOTE: minitest 5 will be the last in the minitest family to support
-  #       ruby 1.8 and 1.9 (and maybe 2.0?). If you need to keep using 1.8
-  #       or 1.9, you need to pin your dependency to minitest with
-  #       something like "~> 5.0".
-  #
-  #       Further, minitest 6 will be dropping the following:
-  #
-  #       + MiniTest (it's been Minitest for *years*)
-  #       + MiniTest::Unit
-  #       + MiniTest::Unit::TestCase
-  #       + assert_send (unless you argue for it well)
-  #   EOM
-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|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",
-  }
-  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

data/vendor/bundle/gems/minitest-5.10.1/design_rationale.rb DELETED Viewed

@@ -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

data/vendor/bundle/gems/minitest-5.10.1/lib/hoe/minitest.rb DELETED Viewed

@@ -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

data/vendor/bundle/gems/minitest-5.10.1/lib/minitest.rb DELETED Viewed

@@ -1,842 +0,0 @@
-require "optparse"
-require "thread"
-require "mutex_m"
-require "minitest/parallel"
-##
-# :include: README.rdoc
-module Minitest
-  VERSION = "5.10.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
-  self.parallel_executor = Parallel::Executor.new((ENV["N"] || 2).to_i)
-  ##
-  # 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
-      at_exit {
-        @@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
-    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
-      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:
-    backtrace_filter.filter bt
-  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
-    ##
-    # Name of the run.
-    def name
-      @NAME
-    end
-    ##
-    # Set the name of the run.
-    def name= o
-      @NAME = o
-    end
-    def self.inherited klass # :nodoc:
-      self.runnables << klass
-      super
-    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 =~ %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
-    def marshal_dump # :nodoc:
-      [self.name, self.failures, self.assertions]
-    end
-    def marshal_load ary # :nodoc:
-      self.name, self.failures, self.assertions = 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. Eg ".", "F", or "E".
-    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
-  ##
-  # 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
-    ##
-    # Record a result and output the Runnable#result_code. 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
-      if options[:verbose] then
-        io.print "%s#%s = " % [klass, 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.
-  class StatisticsReporter < Reporter
-    # :stopdoc:
-    attr_accessor :assertions
-    attr_accessor :count
-    attr_accessor :results
-    attr_accessor :start_time
-    attr_accessor :total_time
-    attr_accessor :failures
-    attr_accessor :errors
-    attr_accessor :skips
-    # :startdoc:
-    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
-    def report # :nodoc:
-      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
-      io.puts aggregated_results
-      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 # :nodoc:
-      filtered_results = results.dup
-      filtered_results.reject!(&:skipped?) unless options[:verbose]
-      s = filtered_results.each_with_index.map { |result, i|
-        "\n%3d) %s" % [i+1, result]
-      }.join("\n") + "\n"
-      s.force_encoding(io.external_encoding) if
-        ENCS and io.external_encoding and s.encoding != io.external_encoding
-      s
-    end
-    alias to_s aggregated_results
-    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
-  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
-    attr_accessor :exception # :nodoc:
-    def initialize exception # :nodoc:
-      super "Unexpected exception"
-      self.exception = exception
-    end
-    def backtrace # :nodoc:
-      self.exception.backtrace
-    end
-    def error # :nodoc:
-      self.exception
-    end
-    def message # :nodoc:
-      bt = Minitest.filter_backtrace(self.backtrace).join "\n    "
-      "#{self.exception.class}: #{self.exception.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
-      "maglev" == platform
-    end
-    ##
-    # Is this running on mri?
-    def mri? platform = RUBY_DESCRIPTION
-      /^ruby/ =~ platform
-    end
-    ##
-    # Is this running on rubinius?
-    def rubinius? platform = defined?(RUBY_ENGINE) && RUBY_ENGINE
-      "rbx" == platform
-    end
-    ##
-    # Is this running on windows?
-    def windows? platform = RUBY_PLATFORM
-      /mswin|mingw/ =~ platform
-    end
-  end
-  class BacktraceFilter # :nodoc:
-    def filter bt
-      return ["No backtrace"] unless bt
-      return bt.dup if $DEBUG
-      mt_re = %r%lib/minitest%
-      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 self" unless klass === 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
-  # :startdoc:
-end
-require "minitest/test"