minitest 4.7.5 → 5.0.0

data/.autotest

@@ -4,7 +4,7 @@ require 'autotest/restart'
 require 'autotest/rcov' if ENV['RCOV']
 
 Autotest.add_hook :initialize do |at|
-  at.testlib = 'minitest/unit'
+  at.testlib = 'minitest/autorun'
 
   at.extra_class_map["MiniTest::Spec"]           = "test/test_minitest_spec.rb"
   at.extra_class_map["TestMeta"]                 = "test/test_minitest_spec.rb"
@@ -18,4 +18,3 @@ end
 
 # require 'autotest/rcov'
 # Autotest::RCov.command = 'rcov_info'
-

data/History.txt

@@ -1,24 +1,75 @@
-=== 4.7.5 / 2013-06-21
-
-* 2 bug fixes:
-
-  * Fix Spec#describe_stack to be thread local.
-  * Fix multithreaded test failures by defining Time local to mock test namespace
-
-=== 4.7.4 / 2013-05-01
-
-This is probably the last release of the 4.x series. It will be merged
-to ruby and will be put into maintenance mode there.
-
-I'm not set in stone on this, but at this point further development of
-minitest (5+) will be gem-only. It is just too hard to work w/in
-ruby-core w/ test-unit compatibility holding minitest development
-back.
-
-* 2 minor enhancements:
-
-  * Added count/size to ParallelEach to fix use w/in stdlib's test/unit. :( (btaitelb)
-  * Allow disabling of info_signal handler in runner. (erikh)
+=== 5.0.0 / 2013-05-10
+
+Oh god... here we go...
+
+Minitest 5:
+
+Deaths in the family:
+
+* MiniTest.runner is dead. No more manager objects.
+* MiniTest::Unit#record is dead. Use a Reporter instance instead.
+* MiniTest::Unit._run_* is dead. Runnable things are responsible for their own runs.
+* MiniTest::Unit.output is dead. No more centralized IO.
+
+Major (oft incompatible) changes:
+
+* Renamed MiniTest to Minitest. Your pinkies will thank me. (aliased to MiniTest)
+* Removed MiniTest::Unit entirely. No more manager objects.
+* Added Minitest::Runnable. Everything minitest can run subclasses this.
+* Renamed MiniTest::Unit::TestCase to Minitest::Test (subclassing Runnable).
+* Added Minitest::Benchmark.
+  * Your benchmarks need to move to their own subclass.
+  * Benchmarks using the spec DSL have to have "Bench" somewhere in their describe.
+* MiniTest::Unit.after_tests moved to Minitest.after_tests
+* MiniTest::Unit.autorun is now Minitest.autorun. Just require minitest/autorun pls.
+* Removed ParallelEach#grep since it isn't used anywhere.
+* Renamed Runnable#__name__ to Runnable#name (but uses @NAME internally).
+* Runnable#run needs to return self. Allows for swapping of results as needed.
+
+Minor moves:
+
+* Moved Assertions module to minitest/assertions.rb
+* Moved Expectations module to minitest/expectations.rb
+* Moved Test to minitest/test.rb
+* Moved everything else in minitest/unit.rb to minitest.rb
+* minitest/unit.rb is now just a small (user-test only) compatibility layer.
+* Moved most of minitest/pride into minitest/pride_plugin.
+* minitest/pride now just activates pride.
+* Moved ParallelEach under Minitest.
+
+Additions:
+
+* Added a plugin system that can extend command-line options.
+* Added Minitest.extensions.
+* Added Minitest.reporter (only available during startup).
+* Added Minitest.run(args). This is the very top of any Minitest run.
+* Added Minitest::Reporter. Everything minitest can report goes through here.
+  * Minitest.reporter is a composite so you can add your own.
+* Added Minitest::CompositeReporter. Much easier to extend with your own reporters.
+* Added UnexpectedError, an Assertion subclass, to wrap up errors.
+* Minitest::Test#run is now freakin' beautiful. 47 -> 17 loc
+
+Other:
+
+* Removed Object.infect_with_assertions (it was already dead code).
+* Runnables are responsible for knowing their result_code (eg "." or "F").
+* Minitest.autorun now returns boolean, not exit code.
+* Added FAQ entry for extending via modules. (phiggins)
+* Implement Runnable#dup to cleanse state back to test results. Helps with serialization. pair:tenderlove
+* Moved ParallelEach under Minitest.
+* Runnable#run needs to return self. Allows for swapping of results as needed.
+* Minitest.init_plugins passes down options.
+* Minitest.load_plugins only loads once.
+* Fixed minitest/pride to work with rake test loader again. (tmiller)
+* Added count/size to ParallelEach to fix use w/in stdlib's test/unit. :( (btaitelb)
+
+Voodoo:
+
+* Removed mutex from minitest.rb (phiggins)
+* Removed mutex from test.rb (phiggins)
+* Removed Minitest::Reporter.synchronize (phiggins)
+* Removed Minitest::Test.synchronize (phiggins)
+* Upon loading minitest/parallel_each, record, capture_io and capture_subprocess_io are doped with synchronization code. (phiggins)
 
 === 4.7.3 / 2013-04-20
 

data/Manifest.txt

@@ -5,16 +5,22 @@ README.txt
 Rakefile
 design_rationale.rb
 lib/hoe/minitest.rb
+lib/minitest.rb
+lib/minitest/assertions.rb
 lib/minitest/autorun.rb
 lib/minitest/benchmark.rb
+lib/minitest/expectations.rb
 lib/minitest/hell.rb
 lib/minitest/mock.rb
 lib/minitest/parallel_each.rb
 lib/minitest/pride.rb
+lib/minitest/pride_plugin.rb
 lib/minitest/spec.rb
+lib/minitest/test.rb
 lib/minitest/unit.rb
 test/minitest/metametameta.rb
 test/minitest/test_minitest_benchmark.rb
 test/minitest/test_minitest_mock.rb
+test/minitest/test_minitest_reporter.rb
 test/minitest/test_minitest_spec.rb
 test/minitest/test_minitest_unit.rb

data/README.txt

@@ -90,9 +90,9 @@ Given that you'd like to test the following class:
 
 === Unit tests
 
-  require 'minitest/autorun'
+  require "minitest/autorun"
 
-  class TestMeme < MiniTest::Unit::TestCase
+  class TestMeme < Minitest::Test
     def setup
       @meme = Meme.new
     end
@@ -112,7 +112,7 @@ Given that you'd like to test the following class:
 
 === Specs
 
-  require 'minitest/autorun'
+  require "minitest/autorun"
 
   describe Meme do
     before do
@@ -138,13 +138,12 @@ https://github.com/zenspider/minitest-matchers
 
 === Benchmarks
 
-Add benchmarks to your regular unit tests. If the unit tests fail, the
-benchmarks won't run.
+Add benchmarks to your tests.
 
   # optionally run benchmarks, good for CI-only work!
-  require 'minitest/benchmark' if ENV["BENCH"]
+  require "minitest/benchmark" if ENV["BENCH"]
 
-  class TestMeme < MiniTest::Unit::TestCase
+  class TestMeme < Minitest::Benchmark
     # Override self.bench_range or default range is [1, 10, 100, 1_000, 10_000]
     def bench_my_algorithm
       assert_performance_linear 0.9999 do |n| # n is a range value
@@ -155,9 +154,10 @@ benchmarks won't run.
 
 Or add them to your specs. If you make benchmarks optional, you'll
 need to wrap your benchmarks in a conditional since the methods won't
-be defined.
+be defined. In minitest 5, the describe name needs to match
+/Bench(mark)?$/.
 
-  describe Meme do
+  describe "Meme Benchmark" do
     if ENV["BENCH"] then
       bench_performance_linear "my_algorithm", 0.9999 do |n|
         100.times do
@@ -190,7 +190,7 @@ Output is tab-delimited to make it easy to paste into a spreadsheet.
     end
   end
 
-  require 'minitest/autorun'
+  require "minitest/autorun"
 
   describe MemeAsker do
     before do
@@ -229,57 +229,30 @@ new non-existing method:
     ...
   end
 
-=== Customizable Test Runner Types:
-
-MiniTest::Unit.runner=(runner) provides an easy way of creating custom
-test runners for specialized needs. Justin Weiss provides the
-following real-world example to create an alternative to regular
-fixture loading:
+== Writing Extensions
 
-  class MiniTestWithHooks::Unit < MiniTest::Unit
-    def before_suites
-    end
+To define a plugin, add a file named minitest/XXX_plugin.rb to your
+project/gem. Minitest will find and require that file using
+Gem.find_files. It will then try to call plugin_XXX_init during
+startup. The option processor will also try to call plugin_XXX_options
+passing the OptionParser instance and the current options hash. This
+lets you register your own command-line options. Here's a totally
+bogus example:
 
-    def after_suites
-    end
+    # minitest/bogus_plugin.rb:
 
-    def _run_suites(suites, type)
-      begin
-        before_suites
-        super(suites, type)
-      ensure
-        after_suites
+    module Minitest
+      def self.plugin_bogus_options(opts, options)
+        opts.on "--myci", "Report results to my CI" do
+          options[:myci] = true
+        end
       end
-    end
 
-    def _run_suite(suite, type)
-      begin
-        suite.before_suite
-        super(suite, type)
-      ensure
-        suite.after_suite
+      def self.plugin_bogus_init
+        ARGV << "-p" # all pride, all the time
+        self.reporter << MyCI.new if options[:myci]
       end
     end
-  end
-
-  module MiniTestWithTransactions
-    class Unit < MiniTestWithHooks::Unit
-      include TestSetupHelper
-
-      def before_suites
-        super
-        setup_nested_transactions
-        # load any data we want available for all tests
-      end
-
-      def after_suites
-        teardown_nested_transactions
-        super
-      end
-    end
-  end
-
-  MiniTest::Unit.runner = MiniTestWithTransactions::Unit.new
 
 == FAQ
 
@@ -329,11 +302,35 @@ or you can extend the Worker class (within the test file!), like:
       include ::MiniTest::Expectations
     end
 
+=== How to share code across test classes?
+
+Use a module. That's exactly what they're for:
+
+    module UsefulStuff
+      def useful_method
+        # ...
+      end
+    end
+
+    describe Blah do
+      include UsefulStuff
+
+      def test_whatever
+        # useful_method available here
+      end
+    end
+
+Remember, `describe` simply creates test classes. It's just ruby at
+the end of the day and all your normal Good Ruby Rules (tm) apply. If
+you want to extend your test using setup/teardown via a module, just
+make sure you ALWAYS call super. before/after automatically call super
+for you, so make sure you don't do it twice.
+
 == Known Extensions:
 
-capybara_minitest_spec      :: Bridge between Capybara RSpec matchers and MiniTest::Spec expectations (e.g. page.must_have_content('Title')).
+capybara_minitest_spec      :: Bridge between Capybara RSpec matchers and MiniTest::Spec expectations (e.g. page.must_have_content("Title")).
 minispec-metadata           :: Metadata for describe/it blocks
-                               (e.g. `it 'requires JS driver', js: true do`)
+                               (e.g. `it "requires JS driver", js: true do`)
 minitest-ansi               :: Colorize minitest output with ANSI colors.
 minitest-around             :: Around block for minitest. An alternative to setup/teardown dance.
 minitest-capistrano         :: Assertions and expectations for testing Capistrano recipes
@@ -416,11 +413,11 @@ Authors... Please send me a pull request with a description of your minitest ext
   sudo gem install minitest
 
 On 1.9, you already have it. To get newer candy you can still install
-the gem, but you'll need to activate the gem explicitly to use it:
+the gem, and then requiring "minitest/autorun" should automatically
+pull it in. If not, you'll need to do it yourself:
 
-  require 'rubygems'
-  gem 'minitest' # ensures you're using the gem, and not the built in MT
-  require 'minitest/autorun'
+  gem "minitest"     # ensures you"re using the gem, and not the built-in MT
+  require "minitest/autorun"
 
   # ... usual testing stuffs ...
 

data/design_rationale.rb

@@ -1,6 +1,6 @@
 # Specs:                               # Equivalent Unit Tests:
 ###############################################################################
-describe Thingy do                     # class TestThingy < MiniTest::Unit::TestCase
+describe Thingy do                     # class TestThingy < Minitest::Test
   before do                            #   def setup
     do_some_setup                      #     super
   end                                  #     do_some_setup

data/lib/hoe/minitest.rb

@@ -5,18 +5,22 @@ end
 
 module Hoe::Minitest
   def initialize_minitest
+    dir = "../../minitest/dev/lib"
+    Hoe.add_include_dirs dir if File.directory? dir
+
     gem "minitest"
-    require 'minitest/unit'
-    version = MiniTest::Unit::VERSION.split(/\./).first(2).join(".")
+    require "minitest"
+    version = Minitest::VERSION.split(/\./).first(2).join(".")
 
-    dependency 'minitest', "~> #{version}", :development unless
-      self.name == "minitest"
+    dependency "minitest", "~> #{version}", :development unless
+      self.name == "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"'
+    self.test_prelude = 'gem "minitest"' unless
+      self.name == "minitest" or ENV["MT_NO_ISOLATE"]
   end
 end

data/lib/minitest.rb

@@ -0,0 +1,639 @@
+require "optparse"
+
+##
+# :include: README.txt
+
+module Minitest
+  VERSION = "5.0.0" # :nodoc:
+
+  @@installed_at_exit ||= false
+  @@after_run = []
+  @extensions = []
+
+  mc = (class << self; self; end)
+
+  ##
+  # 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
+
+  ##
+  # Registers Minitest to run at process exit
+
+  def self.autorun
+    at_exit {
+      next if $! and not $!.kind_of? SystemExit
+
+      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?
+
+    Gem.find_files("minitest/*_plugin.rb").each do |plugin_path|
+      require plugin_path
+      name = File.basename plugin_path, "_plugin.rb"
+      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)
+  #       __run(reporter, options)
+  #         Runnable.runnables.each
+  #           runnable.run(reporter, options)
+  #             self.runnable_methods.each
+  #               self.new.run runnable_method
+
+  def self.run args = []
+    self.load_plugins
+
+    options = process_args args
+
+    reporter = CompositeReporter.new
+    reporter << Reporter.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
+
+    reporter.run_and_report do
+      __run reporter, options
+    end
+
+    reporter.passed?
+  end
+
+  ##
+  # Internal run method. Responsible for telling all Runnable
+  # sub-classes to run.
+  #
+  # NOTE: this method is redefined in parallel_each.rb, which is
+  # loaded if a Runnable calls parallelize_me!.
+
+  def self.__run reporter, options
+    Runnable.runnables.each do |runnable|
+      runnable.run reporter, options
+    end
+  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 "-s", "--seed SEED", Integer, "Sets random seed" 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 /pattern/ or string." do |a|
+        options[:filter] = 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] = srand % 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 =~ /\/(.*)\//
+
+      filtered_methods = self.runnable_methods.find_all { |m|
+        filter === m || filter === "#{self}##{m}"
+      }
+
+      filtered_methods.each do |method_name|
+        result = self.new(method_name).run
+        raise "#{self}#run _must_ return self" unless self === result
+        reporter.record result
+      end
+    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 dup # :nodoc:
+      obj = self.class.new self.name
+
+      obj.name       = self.name
+      obj.failures   = self.failures.dup
+      obj.assertions = self.assertions
+
+      obj
+    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
+
+  ##
+  # Collects and reports the result of all runs.
+
+  class Reporter
+    ##
+    # The count of assertions run.
+
+    attr_accessor :assertions
+
+    ##
+    # The count of runnable methods ran.
+
+    attr_accessor :count
+
+    ##
+    # The IO used to report.
+
+    attr_accessor :io
+
+    ##
+    # Command-line options for this run.
+
+    attr_accessor :options
+
+    ##
+    # The results of all the runs. (Non-passing only to cut down on memory)
+
+    attr_accessor :results
+
+    ##
+    # The start time of the run.
+
+    attr_accessor :start_time
+
+    attr_accessor :sync, :old_sync # :nodoc:
+
+    def initialize io = $stdout, options = {} # :nodoc:
+      self.io      = io
+      self.options = options
+
+      self.assertions = 0
+      self.count      = 0
+      self.results    = []
+      self.start_time = nil
+    end
+
+    ##
+    # Did this run pass?
+
+    def passed?
+      results.all?(&:skipped?)
+    end
+
+    ##
+    # Top-level method to ensure that start and report are called.
+    # Yields to the caller.
+
+    def run_and_report
+      start
+
+      yield
+
+      report
+    end
+
+    ##
+    # Starts reporting on the run.
+
+    def start
+      self.sync = io.respond_to? :"sync=" # stupid emacs
+      self.old_sync, io.sync = io.sync, true if self.sync
+
+      self.start_time = Time.now
+
+      io.puts "Run options: #{options[:args]}"
+      io.puts
+      io.puts "# Running:"
+      io.puts
+    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
+      self.count += 1
+      self.assertions += result.assertions
+
+      io.print "%s#%s = %.2f s = " % [result.class, result.name, result.time] if
+      options[:verbose]
+      io.print result.result_code
+      io.puts if options[:verbose]
+
+      results << result if not result.passed? or result.skipped?
+    end
+
+    ##
+    # Outputs the summary of the run.
+
+    def report
+      aggregate = results.group_by { |r| r.failure.class }
+      aggregate.default = [] # dumb. group_by should provide this
+
+      f = aggregate[Assertion].size
+      e = aggregate[UnexpectedError].size
+      s = aggregate[Skip].size
+      t = Time.now - start_time
+
+      io.puts # finish the dots
+      io.puts
+      io.puts "Finished in %.6fs, %.4f runs/s, %.4f assertions/s." %
+        [t, count / t, self.assertions / t]
+
+      format = "%d runs, %d assertions, %d failures, %d errors, %d skips"
+      summary = format % [count, self.assertions, f, e, s]
+
+      filtered_results = results.dup
+      filtered_results.reject!(&:skipped?) unless options[:verbose]
+
+      filtered_results.each_with_index do |result, i|
+        io.puts "\n%3d) %s" % [i+1, result]
+      end
+
+      io.puts
+      io.puts summary
+
+      io.sync = self.old_sync if self.sync
+    end
+  end
+
+  ##
+  # Dispatch to multiple reporters as one.
+
+  class CompositeReporter < Reporter
+    ##
+    # The list of reporters to dispatch to.
+
+    attr_accessor :reporters
+
+    def initialize *reporters # :nodoc:
+      self.reporters = reporters
+    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 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
+      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 TestCase 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 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
+
+      new_bt = bt.take_while { |line| line !~ /lib\/minitest/ }
+      new_bt = bt.select     { |line| line !~ /lib\/minitest/ } if new_bt.empty?
+      new_bt = bt.dup                                           if new_bt.empty?
+
+      new_bt
+    end
+  end
+
+  self.backtrace_filter = BacktraceFilter.new
+end
+
+require "minitest/test"
+require "minitest/unit" unless defined?(MiniTest) # compatibility layer only