minitest 4.7.5 → 5.0.7

data/test/minitest/test_minitest_unit.rb

@@ -5,7 +5,7 @@ module MyModule; end
 class AnError < StandardError; include MyModule; end
 class ImmutableString < String; def inspect; super.freeze; end; end
 
-class TestMiniTestUnit < MetaMetaMetaTestCase
+class TestMinitestUnit < MetaMetaMetaTestCase
   parallelize_me!
 
   pwd = Pathname.new File.expand_path Dir.pwd
@@ -17,98 +17,6 @@ class TestMiniTestUnit < MetaMetaMetaTestCase
                "#{MINITEST_BASE_DIR}/test.rb:139:in `run'",
                "#{MINITEST_BASE_DIR}/test.rb:106:in `run'"]
 
-  def test_class_puke_with_assertion_failed
-    exception = MiniTest::Assertion.new "Oh no!"
-    exception.set_backtrace ["unhappy"]
-    assert_equal 'F', @tu.puke('SomeClass', 'method_name', exception)
-    assert_equal 1, @tu.failures
-    assert_match(/^Failure.*Oh no!/m, @tu.report.first)
-    assert_match("SomeClass#method_name [unhappy]", @tu.report.first)
-  end
-
-  def test_class_puke_with_assertion_failed_and_long_backtrace
-    bt = (["test/test_some_class.rb:615:in `method_name'",
-           "#{MINITEST_BASE_DIR}/unit.rb:140:in `assert_raises'",
-           "test/test_some_class.rb:615:in `each'",
-           "test/test_some_class.rb:614:in `test_method_name'",
-           "#{MINITEST_BASE_DIR}/test.rb:165:in `__send__'"] +
-          BT_MIDDLE +
-          ["#{MINITEST_BASE_DIR}/test.rb:29"])
-    bt = util_expand_bt bt
-
-    ex_location = util_expand_bt(["test/test_some_class.rb:615"]).first
-
-    exception = MiniTest::Assertion.new "Oh no!"
-    exception.set_backtrace bt
-    assert_equal 'F', @tu.puke('TestSomeClass', 'test_method_name', exception)
-    assert_equal 1, @tu.failures
-    assert_match(/^Failure.*Oh no!/m, @tu.report.first)
-    assert_match("TestSomeClass#test_method_name [#{ex_location}]", @tu.report.first)
-  end
-
-  def test_class_puke_with_assertion_failed_and_user_defined_assertions
-    bt = (["lib/test/my/util.rb:16:in `another_method_name'",
-           "#{MINITEST_BASE_DIR}/unit.rb:140:in `assert_raises'",
-           "lib/test/my/util.rb:15:in `block in assert_something'",
-           "lib/test/my/util.rb:14:in `each'",
-           "lib/test/my/util.rb:14:in `assert_something'",
-           "test/test_some_class.rb:615:in `each'",
-           "test/test_some_class.rb:614:in `test_method_name'",
-           "#{MINITEST_BASE_DIR}/test.rb:165:in `__send__'"] +
-          BT_MIDDLE +
-          ["#{MINITEST_BASE_DIR}/test.rb:29"])
-    bt = util_expand_bt bt
-
-    ex_location = util_expand_bt(["test/test_some_class.rb:615"]).first
-
-    exception = MiniTest::Assertion.new "Oh no!"
-    exception.set_backtrace bt
-    assert_equal 'F', @tu.puke('TestSomeClass', 'test_method_name', exception)
-    assert_equal 1, @tu.failures
-    assert_match(/^Failure.*Oh no!/m, @tu.report.first)
-    assert_match("TestSomeClass#test_method_name [#{ex_location}]", @tu.report.first)
-  end
-
-  def test_class_puke_with_failure_and_flunk_in_backtrace
-    exception = begin
-                  MiniTest::Unit::TestCase.new('fake tc').flunk
-                rescue MiniTest::Assertion => failure
-                  failure
-                end
-    assert_equal 'F', @tu.puke('SomeClass', 'method_name', exception)
-    refute @tu.report.any?{|line| line =~ /in .flunk/}
-  end
-
-  def test_class_puke_with_flunk_and_user_defined_assertions
-    bt = (["lib/test/my/util.rb:16:in `flunk'",
-           "#{MINITEST_BASE_DIR}/unit.rb:140:in `assert_raises'",
-           "lib/test/my/util.rb:15:in `block in assert_something'",
-           "lib/test/my/util.rb:14:in `each'",
-           "lib/test/my/util.rb:14:in `assert_something'",
-           "test/test_some_class.rb:615:in `each'",
-           "test/test_some_class.rb:614:in `test_method_name'",
-           "#{MINITEST_BASE_DIR}/test.rb:165:in `__send__'"] +
-          BT_MIDDLE +
-          ["#{MINITEST_BASE_DIR}/test.rb:29"])
-    bt = util_expand_bt bt
-
-    ex_location = util_expand_bt(["test/test_some_class.rb:615"]).first
-
-    exception = MiniTest::Assertion.new "Oh no!"
-    exception.set_backtrace bt
-    assert_equal 'F', @tu.puke('TestSomeClass', 'test_method_name', exception)
-    assert_equal 1, @tu.failures
-    assert_match(/^Failure.*Oh no!/m, @tu.report.first)
-    assert_match("TestSomeClass#test_method_name [#{ex_location}]", @tu.report.first)
-  end
-
-  def test_class_puke_with_non_failure_exception
-    exception = Exception.new("Oh no again!")
-    assert_equal 'E', @tu.puke('SomeClass', 'method_name', exception)
-    assert_equal 1, @tu.errors
-    assert_match(/^Exception.*Oh no again!/m, @tu.report.first)
-  end
-
   def test_filter_backtrace
     # this is a semi-lame mix of relative paths.
     # I cheated by making the autotest parts not have ./
@@ -124,7 +32,7 @@ class TestMiniTestUnit < MetaMetaMetaTestCase
           "test/test_autotest.rb:62:in `test_add_exception'"]
     ex = util_expand_bt ex
 
-    fu = MiniTest::filter_backtrace(bt)
+    fu = Minitest::filter_backtrace(bt)
 
     assert_equal ex, fu
   end
@@ -134,7 +42,7 @@ class TestMiniTestUnit < MetaMetaMetaTestCase
           BT_MIDDLE +
           ["#{MINITEST_BASE_DIR}/test.rb:29"])
     ex = bt.clone
-    fu = MiniTest::filter_backtrace(bt)
+    fu = Minitest::filter_backtrace(bt)
     assert_equal ex, fu
   end
 
@@ -147,45 +55,46 @@ class TestMiniTestUnit < MetaMetaMetaTestCase
     bt = util_expand_bt bt
 
     ex = ["-e:1"]
-    fu = MiniTest::filter_backtrace bt
+    fu = Minitest::filter_backtrace bt
     assert_equal ex, fu
   end
 
-  def test_default_runner_is_minitest_unit
-    assert_instance_of MiniTest::Unit, MiniTest::Unit.runner
-  end
-
+  # def test_default_runner_is_minitest_unit
+  #   assert_instance_of Minitest::Unit, Minitest::Unit.runner
+  # end
 
   def test_passed_eh_teardown_good
-    test_class = Class.new MiniTest::Unit::TestCase do
+    test_class = Class.new Minitest::Test do
       def teardown; assert true; end
       def test_omg; assert true; end
     end
 
     test = test_class.new :test_omg
-    test.run @tu
+    test.run
     assert test.passed?
   end
 
   def test_passed_eh_teardown_skipped
-    test_class = Class.new MiniTest::Unit::TestCase do
+    test_class = Class.new Minitest::Test do
       def teardown; assert true; end
       def test_omg; skip "bork"; end
     end
 
     test = test_class.new :test_omg
-    test.run @tu
-    assert test.passed?
+    test.run
+
+    assert test.skipped?
+    refute test.passed?
   end
 
   def test_passed_eh_teardown_flunked
-    test_class = Class.new MiniTest::Unit::TestCase do
+    test_class = Class.new Minitest::Test do
       def teardown; flunk;       end
       def test_omg; assert true; end
     end
 
     test = test_class.new :test_omg
-    test.run @tu
+    test.run
     refute test.passed?
   end
 
@@ -198,7 +107,7 @@ class TestMiniTestUnit < MetaMetaMetaTestCase
   end
 end
 
-class TestMiniTestUnitInherited < MetaMetaMetaTestCase
+class TestMinitestUnitInherited < MetaMetaMetaTestCase
   def with_overridden_include
     Class.class_eval do
       def inherited_with_hacks klass
@@ -226,32 +135,35 @@ class TestMiniTestUnitInherited < MetaMetaMetaTestCase
   def test_inherited_hook_plays_nice_with_others
     with_overridden_include do
       assert_throws :inherited_hook do
-        Class.new MiniTest::Unit::TestCase
+        Class.new Minitest::Test
       end
     end
   end
 end
 
-class TestMiniTestRunner < MetaMetaMetaTestCase
+class TestMinitestRunner < MetaMetaMetaTestCase
   # do not parallelize this suite... it just can't handle it.
 
-  def test_class_test_suites
+  def test_class_runnables
     @assertion_count = 0
 
-    tc = Class.new(MiniTest::Unit::TestCase)
+    tc = Class.new(Minitest::Test)
 
-    assert_equal 1, MiniTest::Unit::TestCase.test_suites.size
-    assert_equal [tc], MiniTest::Unit::TestCase.test_suites
+    assert_equal 1, Minitest::Test.runnables.size
+    assert_equal [tc], Minitest::Test.runnables
   end
 
   def test_run_test
-    Class.new MiniTest::Unit::TestCase do
+    @tu =
+    Class.new Minitest::Test do
       attr_reader :foo
 
-      def run_test name
+      def run
         @foo = "hi mom!"
         super
         @foo = "okay"
+
+        self # per contract
       end
 
       def test_something
@@ -262,16 +174,17 @@ class TestMiniTestRunner < MetaMetaMetaTestCase
     expected = clean <<-EOM
       .
 
-      Finished tests in 0.00
+      Finished in 0.00
 
-      1 tests, 1 assertions, 0 failures, 0 errors, 0 skips
+      1 runs, 1 assertions, 0 failures, 0 errors, 0 skips
     EOM
 
     assert_report expected
   end
 
   def test_run_error
-    Class.new MiniTest::Unit::TestCase do
+    @tu =
+    Class.new Minitest::Test do
       def test_something
         assert true
       end
@@ -284,21 +197,22 @@ class TestMiniTestRunner < MetaMetaMetaTestCase
     expected = clean <<-EOM
       E.
 
-      Finished tests in 0.00
+      Finished in 0.00
 
         1) Error:
       #<Class:0xXXX>#test_error:
       RuntimeError: unhandled exception
           FILE:LINE:in \`test_error\'
 
-      2 tests, 1 assertions, 0 failures, 1 errors, 0 skips
+      2 runs, 1 assertions, 0 failures, 1 errors, 0 skips
     EOM
 
     assert_report expected
   end
 
   def test_run_error_teardown
-    Class.new MiniTest::Unit::TestCase do
+    @tu =
+    Class.new Minitest::Test do
       def test_something
         assert true
       end
@@ -311,21 +225,22 @@ class TestMiniTestRunner < MetaMetaMetaTestCase
     expected = clean <<-EOM
       E
 
-      Finished tests in 0.00
+      Finished in 0.00
 
         1) Error:
       #<Class:0xXXX>#test_something:
       RuntimeError: unhandled exception
           FILE:LINE:in \`teardown\'
 
-      1 tests, 1 assertions, 0 failures, 1 errors, 0 skips
+      1 runs, 1 assertions, 0 failures, 1 errors, 0 skips
     EOM
 
     assert_report expected
   end
 
   def test_run_failing
-    Class.new MiniTest::Unit::TestCase do
+    @tu =
+    Class.new Minitest::Test do
       def test_something
         assert true
       end
@@ -338,20 +253,21 @@ class TestMiniTestRunner < MetaMetaMetaTestCase
     expected = clean <<-EOM
       F.
 
-      Finished tests in 0.00
+      Finished in 0.00
 
         1) Failure:
       #<Class:0xXXX>#test_failure [FILE:LINE]:
       Failed assertion, no message given.
 
-      2 tests, 2 assertions, 1 failures, 0 errors, 0 skips
+      2 runs, 2 assertions, 1 failures, 0 errors, 0 skips
     EOM
 
     assert_report expected
   end
 
   def test_run_failing_filtered
-    Class.new MiniTest::Unit::TestCase do
+    @tu =
+    Class.new Minitest::Test do
       def test_something
         assert true
       end
@@ -364,9 +280,9 @@ class TestMiniTestRunner < MetaMetaMetaTestCase
     expected = clean <<-EOM
       .
 
-      Finished tests in 0.00
+      Finished in 0.00
 
-      1 tests, 1 assertions, 0 failures, 0 errors, 0 skips
+      1 runs, 1 assertions, 0 failures, 0 errors, 0 skips
     EOM
 
     assert_report expected, %w[--name /some|thing/ --seed 42]
@@ -375,20 +291,22 @@ class TestMiniTestRunner < MetaMetaMetaTestCase
   def assert_filtering name, expected, a = false
     args = %W[--name #{name} --seed 42]
 
-    alpha = Class.new MiniTest::Unit::TestCase do
+    alpha = Class.new Minitest::Test do
       define_method :test_something do
         assert a
       end
     end
     Object.const_set(:Alpha, alpha)
 
-    beta = Class.new MiniTest::Unit::TestCase do
+    beta = Class.new Minitest::Test do
       define_method :test_something do
         assert true
       end
     end
     Object.const_set(:Beta, beta)
 
+    @tus = [alpha, beta]
+
     assert_report expected, args
   ensure
     Object.send :remove_const, :Alpha
@@ -399,9 +317,9 @@ class TestMiniTestRunner < MetaMetaMetaTestCase
     expected = clean <<-EOM
       .
 
-      Finished tests in 0.00
+      Finished in 0.00
 
-      1 tests, 1 assertions, 0 failures, 0 errors, 0 skips
+      1 runs, 1 assertions, 0 failures, 0 errors, 0 skips
     EOM
 
     assert_filtering "/Beta#test_something/", expected
@@ -411,9 +329,9 @@ class TestMiniTestRunner < MetaMetaMetaTestCase
     expected = clean <<-EOM
       .
 
-      Finished tests in 0.00
+      Finished in 0.00
 
-      1 tests, 1 assertions, 0 failures, 0 errors, 0 skips
+      1 runs, 1 assertions, 0 failures, 0 errors, 0 skips
     EOM
 
     assert_filtering "Beta#test_something", expected
@@ -423,16 +341,17 @@ class TestMiniTestRunner < MetaMetaMetaTestCase
     expected = clean <<-EOM
       ..
 
-      Finished tests in 0.00
+      Finished in 0.00
 
-      2 tests, 2 assertions, 0 failures, 0 errors, 0 skips
+      2 runs, 2 assertions, 0 failures, 0 errors, 0 skips
     EOM
 
     assert_filtering "test_something", expected, :pass
   end
 
   def test_run_passing
-    Class.new MiniTest::Unit::TestCase do
+    @tu =
+    Class.new Minitest::Test do
       def test_something
         assert true
       end
@@ -441,16 +360,26 @@ class TestMiniTestRunner < MetaMetaMetaTestCase
     expected = clean <<-EOM
       .
 
-      Finished tests in 0.00
+      Finished in 0.00
 
-      1 tests, 1 assertions, 0 failures, 0 errors, 0 skips
+      1 runs, 1 assertions, 0 failures, 0 errors, 0 skips
     EOM
 
     assert_report expected
   end
 
+  def restore_env
+    old_value = ENV["MT_NO_SKIP_MSG"]
+    ENV.delete "MT_NO_SKIP_MSG"
+
+    yield
+  ensure
+    ENV["MT_NO_SKIP_MSG"] = old_value
+  end
+
   def test_run_skip
-    Class.new MiniTest::Unit::TestCase do
+    @tu =
+    Class.new Minitest::Test do
       def test_something
         assert true
       end
@@ -463,16 +392,21 @@ class TestMiniTestRunner < MetaMetaMetaTestCase
     expected = clean <<-EOM
       S.
 
-      Finished tests in 0.00
+      Finished in 0.00
+
+      2 runs, 1 assertions, 0 failures, 0 errors, 1 skips
 
-      2 tests, 1 assertions, 0 failures, 0 errors, 1 skips
+      You have skipped tests. Run with --verbose for details.
     EOM
 
-    assert_report expected
+    restore_env do
+      assert_report expected
+    end
   end
 
   def test_run_skip_verbose
-    Class.new MiniTest::Unit::TestCase do
+    @tu =
+    Class.new Minitest::Test do
       def test_something
         assert true
       end
@@ -486,32 +420,31 @@ class TestMiniTestRunner < MetaMetaMetaTestCase
       #<Class:0xXXX>#test_skip = 0.00 s = S
       #<Class:0xXXX>#test_something = 0.00 s = .
 
-
-      Finished tests in 0.00
+      Finished in 0.00
 
         1) Skipped:
       #<Class:0xXXX>#test_skip [FILE:LINE]:
       not yet
 
-      2 tests, 1 assertions, 0 failures, 0 errors, 1 skips
+      2 runs, 1 assertions, 0 failures, 0 errors, 1 skips
     EOM
 
     assert_report expected, %w[--seed 42 --verbose]
   end
 
   def test_run_with_other_runner
-    MiniTest::Unit.runner = Class.new MiniTest::Unit do
-      def _run_suite suite, type
-        suite.before_suite # Run once before each suite
-        super suite, type
+    @tu =
+    Class.new Minitest::Test do
+      def self.run reporter, options = {}
+        @reporter = reporter
+        before_my_suite
+        super
       end
-    end.new
 
-    Class.new MiniTest::Unit::TestCase do
       def self.name; "wacky!" end
 
-      def self.before_suite
-        MiniTest::Unit.output.puts "Running #{self.name} tests"
+      def self.before_my_suite
+        @reporter.reporters.first.io.puts "Running #{self.name} tests"
         @@foo = 1
       end
 
@@ -528,9 +461,9 @@ class TestMiniTestRunner < MetaMetaMetaTestCase
       Running wacky! tests
       ..
 
-      Finished tests in 0.00
+      Finished in 0.00
 
-      2 tests, 2 assertions, 0 failures, 0 errors, 0 skips
+      2 runs, 2 assertions, 0 failures, 0 errors, 0 skips
     EOM
 
     assert_report expected
@@ -558,7 +491,7 @@ class TestMiniTestRunner < MetaMetaMetaTestCase
   end
 
   def test_parallel_each_size
-    assert_equal 0, ParallelEach.new([]).size
+    assert_equal 0, Minitest::ParallelEach.new([]).size
   end
 
   def test_run_parallel
@@ -578,7 +511,8 @@ class TestMiniTestRunner < MetaMetaMetaTestCase
       main_latch.release
     }
 
-    Class.new MiniTest::Unit::TestCase do
+    @tu =
+    Class.new Minitest::Test do
       parallelize_me!
 
       test_count.times do |i|
@@ -598,9 +532,9 @@ class TestMiniTestRunner < MetaMetaMetaTestCase
     expected = clean <<-EOM
       ..
 
-      Finished tests in 0.00
+      Finished in 0.00
 
-      2 tests, 2 assertions, 0 failures, 0 errors, 0 skips
+      2 runs, 2 assertions, 0 failures, 0 errors, 0 skips
     EOM
 
     assert_report expected
@@ -608,12 +542,13 @@ class TestMiniTestRunner < MetaMetaMetaTestCase
   end
 end
 
-class TestMiniTestUnitOrder < MetaMetaMetaTestCase
+class TestMinitestUnitOrder < MetaMetaMetaTestCase
   # do not parallelize this suite... it just can't handle it.
 
   def test_before_setup
     call_order = []
-    Class.new MiniTest::Unit::TestCase do
+    @tu =
+    Class.new Minitest::Test do
       define_method :setup do
         super()
         call_order << :setup
@@ -626,9 +561,7 @@ class TestMiniTestUnitOrder < MetaMetaMetaTestCase
       def test_omg; assert true; end
     end
 
-    with_output do
-      @tu.run %w[--seed 42]
-    end
+    run_tu_with_fresh_reporter
 
     expected = [:before_setup, :setup]
     assert_equal expected, call_order
@@ -636,7 +569,8 @@ class TestMiniTestUnitOrder < MetaMetaMetaTestCase
 
   def test_after_teardown
     call_order = []
-    Class.new MiniTest::Unit::TestCase do
+    @tu =
+    Class.new Minitest::Test do
       define_method :teardown do
         super()
         call_order << :teardown
@@ -649,9 +583,7 @@ class TestMiniTestUnitOrder < MetaMetaMetaTestCase
       def test_omg; assert true; end
     end
 
-    with_output do
-      @tu.run %w[--seed 42]
-    end
+    run_tu_with_fresh_reporter
 
     expected = [:teardown, :after_teardown]
     assert_equal expected, call_order
@@ -659,7 +591,8 @@ class TestMiniTestUnitOrder < MetaMetaMetaTestCase
 
   def test_all_teardowns_are_guaranteed_to_run
     call_order = []
-    Class.new MiniTest::Unit::TestCase do
+    @tu =
+    Class.new Minitest::Test do
       define_method :after_teardown do
         super()
         call_order << :after_teardown
@@ -681,9 +614,7 @@ class TestMiniTestUnitOrder < MetaMetaMetaTestCase
       def test_omg; assert true; end
     end
 
-    with_output do
-      @tu.run %w[--seed 42]
-    end
+    run_tu_with_fresh_reporter
 
     expected = [:before_teardown, :teardown, :after_teardown]
     assert_equal expected, call_order
@@ -692,7 +623,7 @@ class TestMiniTestUnitOrder < MetaMetaMetaTestCase
   def test_setup_and_teardown_survive_inheritance
     call_order = []
 
-    parent = Class.new MiniTest::Unit::TestCase do
+    @tu = Class.new Minitest::Test do
       define_method :setup do
         call_order << :setup_method
       end
@@ -706,11 +637,10 @@ class TestMiniTestUnitOrder < MetaMetaMetaTestCase
       end
     end
 
-    _ = Class.new parent
+    run_tu_with_fresh_reporter
 
-    with_output do
-      @tu.run %w[--seed 42]
-    end
+    @tu = Class.new @tu
+    run_tu_with_fresh_reporter
 
     # Once for the parent class, once for the child
     expected = [:setup_method, :test, :teardown_method] * 2
@@ -719,7 +649,54 @@ class TestMiniTestUnitOrder < MetaMetaMetaTestCase
   end
 end
 
-class TestMiniTestUnitTestCase < MiniTest::Unit::TestCase
+class TestMinitestRunnable < Minitest::Test
+  def setup_marshal klass
+    tc = klass.new "whatever"
+    tc.assertions = 42
+    tc.failures << "a failure"
+
+    yield tc if block_given?
+
+    def tc.setup
+      @blah = "blah"
+    end
+    tc.setup
+
+    @tc = tc
+  end
+
+  def assert_marshal expected_ivars
+    new_tc = Marshal.load Marshal.dump @tc
+
+    ivars = new_tc.instance_variables.map(&:to_s).sort
+    assert_equal expected_ivars, ivars
+    assert_equal "whatever",     new_tc.name
+    assert_equal 42,             new_tc.assertions
+    assert_equal ["a failure"],  new_tc.failures
+
+    yield new_tc if block_given?
+  end
+
+  def test_marshal
+    setup_marshal Minitest::Runnable
+
+    assert_marshal %w(@NAME @assertions @failures)
+  end
+end
+
+class TestMinitestTest < TestMinitestRunnable
+  def test_dup
+    setup_marshal Minitest::Test do |tc|
+      tc.time = 3.14
+    end
+
+    assert_marshal %w(@NAME @assertions @failures @time) do |new_tc|
+      assert_in_epsilon 3.14, new_tc.time
+    end
+  end
+end
+
+class TestMinitestUnitTestCase < Minitest::Test
   # do not call parallelize_me! - teardown accesses @tc._assertions
   # which is not threadsafe. Nearly every method in here is an
   # assertion test so it isn't worth splitting it out further.
@@ -729,16 +706,16 @@ class TestMiniTestUnitTestCase < MiniTest::Unit::TestCase
   def setup
     super
 
-    MiniTest::Unit::TestCase.reset
+    Minitest::Test.reset
 
-    @tc = MiniTest::Unit::TestCase.new 'fake tc'
+    @tc = Minitest::Test.new 'fake tc'
     @zomg = "zomg ponies!"
     @assertion_count = 1
   end
 
   def teardown
-    assert_equal(@assertion_count, @tc._assertions,
-                 "expected #{@assertion_count} assertions to be fired during the test, not #{@tc._assertions}") if @tc.passed?
+    assert_equal(@assertion_count, @tc.assertions,
+                 "expected #{@assertion_count} assertions to be fired during the test, not #{@tc.assertions}") if @tc.passed?
   end
 
   def non_verbose
@@ -926,6 +903,8 @@ class TestMiniTestUnitTestCase < MiniTest::Unit::TestCase
   end
 
   def test_delta_consistency
+    @assertion_count = 2
+
     @tc.assert_in_delta 0, 1, 1
 
     util_assert_triggered "Expected |0 - 1| (1) to not be <= 1." do
@@ -958,6 +937,8 @@ class TestMiniTestUnitTestCase < MiniTest::Unit::TestCase
   end
 
   def test_epsilon_consistency
+    @assertion_count = 2
+
     @tc.assert_in_epsilon 1.0, 1.001
 
     msg = "Expected |1.0 - 1.001| (0.000999xxx) to not be <= 0.001."
@@ -989,7 +970,7 @@ class TestMiniTestUnitTestCase < MiniTest::Unit::TestCase
   def test_assert_includes_triggered
     @assertion_count = 3
 
-    e = @tc.assert_raises MiniTest::Assertion do
+    e = @tc.assert_raises Minitest::Assertion do
       @tc.assert_includes [true], false
     end
 
@@ -1180,7 +1161,7 @@ class TestMiniTestUnitTestCase < MiniTest::Unit::TestCase
   def test_assert_raises_skip
     @assertion_count = 0
 
-    util_assert_triggered "skipped", MiniTest::Skip do
+    util_assert_triggered "skipped", Minitest::Skip do
       @tc.assert_raises ArgumentError do
         begin
           raise "blah"
@@ -1192,7 +1173,7 @@ class TestMiniTestUnitTestCase < MiniTest::Unit::TestCase
   end
 
   def test_assert_raises_triggered_different
-    e = assert_raises MiniTest::Assertion do
+    e = assert_raises Minitest::Assertion do
       @tc.assert_raises RuntimeError do
         raise SyntaxError, "icky"
       end
@@ -1214,7 +1195,7 @@ class TestMiniTestUnitTestCase < MiniTest::Unit::TestCase
   end
 
   def test_assert_raises_triggered_different_msg
-    e = assert_raises MiniTest::Assertion do
+    e = assert_raises Minitest::Assertion do
       @tc.assert_raises RuntimeError, "XXX" do
         raise SyntaxError, "icky"
       end
@@ -1237,31 +1218,31 @@ class TestMiniTestUnitTestCase < MiniTest::Unit::TestCase
   end
 
   def test_assert_raises_triggered_none
-    e = assert_raises MiniTest::Assertion do
-      @tc.assert_raises MiniTest::Assertion do
+    e = assert_raises Minitest::Assertion do
+      @tc.assert_raises Minitest::Assertion do
         # do nothing
       end
     end
 
-    expected = "MiniTest::Assertion expected but nothing was raised."
+    expected = "Minitest::Assertion expected but nothing was raised."
 
     assert_equal expected, e.message
   end
 
   def test_assert_raises_triggered_none_msg
-    e = assert_raises MiniTest::Assertion do
-      @tc.assert_raises MiniTest::Assertion, "XXX" do
+    e = assert_raises Minitest::Assertion do
+      @tc.assert_raises Minitest::Assertion, "XXX" do
         # do nothing
       end
     end
 
-    expected = "XXX.\nMiniTest::Assertion expected but nothing was raised."
+    expected = "XXX.\nMinitest::Assertion expected but nothing was raised."
 
     assert_equal expected, e.message
   end
 
   def test_assert_raises_triggered_subclass
-    e = assert_raises MiniTest::Assertion do
+    e = assert_raises Minitest::Assertion do
       @tc.assert_raises StandardError do
         raise AnError
       end
@@ -1390,7 +1371,6 @@ class TestMiniTestUnitTestCase < MiniTest::Unit::TestCase
 
   def test_capture_subprocess_io
     @assertion_count = 0
-    skip "Dunno why but the parallel run of this fails"
 
     non_verbose do
       out, err = capture_subprocess_io do
@@ -1406,7 +1386,7 @@ class TestMiniTestUnitTestCase < MiniTest::Unit::TestCase
   def test_class_asserts_match_refutes
     @assertion_count = 0
 
-    methods = MiniTest::Assertions.public_instance_methods
+    methods = Minitest::Assertions.public_instance_methods
     methods.map! { |m| m.to_s } if Symbol === methods.first
 
     # These don't have corresponding refutes _on purpose_. They're
@@ -1482,7 +1462,7 @@ class TestMiniTestUnitTestCase < MiniTest::Unit::TestCase
   end
 
   def test_prints
-    printer = Class.new { extend MiniTest::Assertions }
+    printer = Class.new { extend Minitest::Assertions }
     @tc.assert_equal '"test"', printer.mu_pp(ImmutableString.new 'test')
   end
 
@@ -1547,7 +1527,7 @@ class TestMiniTestUnitTestCase < MiniTest::Unit::TestCase
   def test_refute_includes_triggered
     @assertion_count = 3
 
-    e = @tc.assert_raises MiniTest::Assertion do
+    e = @tc.assert_raises Minitest::Assertion do
       @tc.refute_includes [true], true
     end
 
@@ -1664,15 +1644,15 @@ class TestMiniTestUnitTestCase < MiniTest::Unit::TestCase
   def test_skip
     @assertion_count = 0
 
-    util_assert_triggered "haha!", MiniTest::Skip do
+    util_assert_triggered "haha!", Minitest::Skip do
       @tc.skip "haha!"
     end
   end
 
-  def test_test_methods_random
+  def test_runnable_methods_random
     @assertion_count = 0
 
-    sample_test_case = Class.new MiniTest::Unit::TestCase do
+    sample_test_case = Class.new Minitest::Test do
       def self.test_order; :random; end
       def test_test1; assert "does not matter" end
       def test_test2; assert "does not matter" end
@@ -1686,13 +1666,13 @@ class TestMiniTestUnitTestCase < MiniTest::Unit::TestCase
                else
                  %w(test_test2 test_test1 test_test3)
                end
-    assert_equal expected, sample_test_case.test_methods
+    assert_equal expected, sample_test_case.runnable_methods
   end
 
-  def test_test_methods_sorted
+  def test_runnable_methods_sorted
     @assertion_count = 0
 
-    sample_test_case = Class.new MiniTest::Unit::TestCase do
+    sample_test_case = Class.new Minitest::Test do
       def self.test_order; :sorted end
       def test_test3; assert "does not matter" end
       def test_test2; assert "does not matter" end
@@ -1700,13 +1680,13 @@ class TestMiniTestUnitTestCase < MiniTest::Unit::TestCase
     end
 
     expected = %w(test_test1 test_test2 test_test3)
-    assert_equal expected, sample_test_case.test_methods
+    assert_equal expected, sample_test_case.runnable_methods
   end
 
   def test_i_suck_and_my_tests_are_order_dependent_bang_sets_test_order_alpha
     @assertion_count = 0
 
-    shitty_test_case = Class.new MiniTest::Unit::TestCase
+    shitty_test_case = Class.new Minitest::Test
 
     shitty_test_case.i_suck_and_my_tests_are_order_dependent!
 
@@ -1716,7 +1696,7 @@ class TestMiniTestUnitTestCase < MiniTest::Unit::TestCase
   def test_i_suck_and_my_tests_are_order_dependent_bang_does_not_warn
     @assertion_count = 0
 
-    shitty_test_case = Class.new MiniTest::Unit::TestCase
+    shitty_test_case = Class.new Minitest::Test
 
     def shitty_test_case.test_order ; :lol end
 
@@ -1725,7 +1705,7 @@ class TestMiniTestUnitTestCase < MiniTest::Unit::TestCase
     end
   end
 
-  def util_assert_triggered expected, klass = MiniTest::Assertion
+  def util_assert_triggered expected, klass = Minitest::Assertion
     e = assert_raises klass do
       yield
     end
@@ -1744,16 +1724,16 @@ class TestMiniTestUnitTestCase < MiniTest::Unit::TestCase
   end
 
   def without_diff
-    old_diff = MiniTest::Assertions.diff
-    MiniTest::Assertions.diff = nil
+    old_diff = Minitest::Assertions.diff
+    Minitest::Assertions.diff = nil
 
     yield
   ensure
-    MiniTest::Assertions.diff = old_diff
+    Minitest::Assertions.diff = old_diff
   end
 end
 
-class TestMiniTestGuard < MiniTest::Unit::TestCase
+class TestMinitestGuard < Minitest::Test
   parallelize_me!
 
   def test_mri_eh
@@ -1777,33 +1757,21 @@ class TestMiniTestGuard < MiniTest::Unit::TestCase
   end
 end
 
-class TestMiniTestUnitRecording < MetaMetaMetaTestCase
+class TestMinitestUnitRecording < MetaMetaMetaTestCase
   # do not parallelize this suite... it just can't handle it.
 
   def assert_run_record(*expected, &block)
-    def @tu.record suite, method, assertions, time, error
-      recording[method] << error
-    end
-
-    def @tu.recording
-      @recording ||= Hash.new { |h,k| h[k] = [] }
-    end
-
-    MiniTest::Unit.runner = @tu
-
-    Class.new MiniTest::Unit::TestCase, &block
+    @tu = Class.new Minitest::Test, &block
 
-    with_output do
-      @tu.run
-    end
+    run_tu_with_fresh_reporter
 
-    recorded = @tu.recording.fetch("test_method").map(&:class)
+    recorded = first_reporter.results.map(&:failures).flatten.map { |f| f.error.class }
 
     assert_equal expected, recorded
   end
 
   def test_record_passing
-    assert_run_record NilClass do
+    assert_run_record do
       def test_method
         assert true
       end
@@ -1811,7 +1779,7 @@ class TestMiniTestUnitRecording < MetaMetaMetaTestCase
   end
 
   def test_record_failing
-    assert_run_record MiniTest::Assertion do
+    assert_run_record Minitest::Assertion do
       def test_method
         assert false
       end
@@ -1827,7 +1795,7 @@ class TestMiniTestUnitRecording < MetaMetaMetaTestCase
   end
 
   def test_record_error_teardown
-    assert_run_record NilClass, RuntimeError do
+    assert_run_record RuntimeError do
       def test_method
         assert true
       end
@@ -1850,8 +1818,36 @@ class TestMiniTestUnitRecording < MetaMetaMetaTestCase
     end
   end
 
+  def test_to_s_error_in_test_and_teardown
+    @tu = Class.new Minitest::Test do
+      def test_method
+        raise AnError
+      end
+
+      def teardown
+        raise "unhandled exception"
+      end
+    end
+
+    run_tu_with_fresh_reporter
+
+    exp = clean "
+      Error:
+      #<Class:0xXXX>#test_method:
+      AnError: AnError
+          FILE:LINE:in `test_method'
+
+      Error:
+      #<Class:0xXXX>#test_method:
+      RuntimeError: unhandled exception
+          FILE:LINE:in `teardown'
+    "
+
+    assert_equal exp.strip, normalize_output(first_reporter.results.first.to_s).strip
+  end
+
   def test_record_skip
-    assert_run_record MiniTest::Skip do
+    assert_run_record Minitest::Skip do
       def test_method
         skip "not yet"
       end