minitest 4.7.5 → 5.0.0

data/test/minitest/test_minitest_spec.rb

@@ -2,8 +2,8 @@
 require "minitest/autorun"
 require "stringio"
 
-class MiniSpecA < MiniTest::Spec; end
-class MiniSpecB < MiniTest::Unit::TestCase; extend MiniTest::Spec::DSL; end
+class MiniSpecA < Minitest::Spec; end
+class MiniSpecB < Minitest::Test; extend Minitest::Spec::DSL; end
 class MiniSpecC < MiniSpecB; end
 class NamedExampleA < MiniSpecA; end
 class NamedExampleB < MiniSpecB; end
@@ -11,10 +11,10 @@ class NamedExampleC < MiniSpecC; end
 class ExampleA; end
 class ExampleB < ExampleA; end
 
-describe MiniTest::Spec do
+describe Minitest::Spec do
   # do not parallelize this suite... it just can"t handle it.
 
-  def assert_triggered expected = "blah", klass = MiniTest::Assertion
+  def assert_triggered expected = "blah", klass = Minitest::Assertion
     @assertion_count += 2
 
     e = assert_raises(klass) do
@@ -32,10 +32,10 @@ describe MiniTest::Spec do
   end
 
   after do
-    self._assertions.must_equal @assertion_count if passed? and not skipped?
+    self.assertions.must_equal @assertion_count if passed? and not skipped?
   end
 
-  it "needs to be able to catch a MiniTest::Assertion exception" do
+  it "needs to be able to catch a Minitest::Assertion exception" do
     @assertion_count = 1
 
     assert_triggered "Expected 1 to not be equal to 1." do
@@ -75,7 +75,7 @@ describe MiniTest::Spec do
     @assertion_count = 2
 
     proc { raise "blah" }.must_raise RuntimeError
-    proc { raise MiniTest::Assertion }.must_raise MiniTest::Assertion
+    proc { raise Minitest::Assertion }.must_raise Minitest::Assertion
   end
 
   it "needs to catch an unexpected exception" do
@@ -83,17 +83,17 @@ describe MiniTest::Spec do
 
     msg = <<-EOM.gsub(/^ {6}/, "").chomp
       [RuntimeError] exception expected, not
-      Class: <MiniTest::Assertion>
-      Message: <"MiniTest::Assertion">
+      Class: <Minitest::Assertion>
+      Message: <"Minitest::Assertion">
       ---Backtrace---
     EOM
 
     assert_triggered msg do
-      proc { raise MiniTest::Assertion }.must_raise RuntimeError
+      proc { raise Minitest::Assertion }.must_raise RuntimeError
     end
 
     assert_triggered "msg.\n#{msg}" do
-      proc { raise MiniTest::Assertion }.must_raise RuntimeError, "msg"
+      proc { raise Minitest::Assertion }.must_raise RuntimeError, "msg"
     end
   end
 
@@ -132,7 +132,6 @@ describe MiniTest::Spec do
                         must_output
                         must_raise
                         must_respond_to
-                        must_send
                         must_throw)
 
     bad = %w[not raise throw send output be_silent]
@@ -523,7 +522,7 @@ describe MiniTest::Spec do
 
 end
 
-describe MiniTest::Spec, :let do
+describe Minitest::Spec, :let do
   i_suck_and_my_tests_are_order_dependent!
 
   def _count
@@ -554,7 +553,7 @@ describe MiniTest::Spec, :let do
   end
 end
 
-describe MiniTest::Spec, :subject do
+describe Minitest::Spec, :subject do
   attr_reader :subject_evaluation_count
 
   subject do
@@ -570,9 +569,9 @@ describe MiniTest::Spec, :subject do
   end
 end
 
-class TestMetaStatic < MiniTest::Unit::TestCase
+class TestMetaStatic < Minitest::Test
   def test_children
-    MiniTest::Spec.children.clear # prevents parallel run
+    Minitest::Spec.children.clear # prevents parallel run
 
     x = y = z = nil
     x = describe "top-level thingy" do
@@ -583,14 +582,16 @@ class TestMetaStatic < MiniTest::Unit::TestCase
       z = describe "second thingy" do end
     end
 
-    assert_equal [x], MiniTest::Spec.children
+    assert_equal [x], Minitest::Spec.children
     assert_equal [y, z], x.children
     assert_equal [], y.children
     assert_equal [], z.children
   end
 end
 
-class TestMeta < MiniTest::Unit::TestCase
+require "minitest/metametameta"
+
+class TestMeta < MetaMetaMetaTestCase
   parallelize_me!
 
   def util_structure
@@ -623,35 +624,35 @@ class TestMeta < MiniTest::Unit::TestCase
   end
 
   def test_register_spec_type
-    original_types = MiniTest::Spec::TYPES.dup
+    original_types = Minitest::Spec::TYPES.dup
 
-    assert_equal [[//, MiniTest::Spec]], MiniTest::Spec::TYPES
+    assert_includes Minitest::Spec::TYPES, [//, Minitest::Spec]
 
-    MiniTest::Spec.register_spec_type(/woot/, TestMeta)
+    Minitest::Spec.register_spec_type(/woot/, TestMeta)
 
     p = lambda do |x| true end
-    MiniTest::Spec.register_spec_type TestMeta, &p
+    Minitest::Spec.register_spec_type TestMeta, &p
 
-    keys = MiniTest::Spec::TYPES.map(&:first)
+    keys = Minitest::Spec::TYPES.map(&:first)
 
     assert_includes keys, /woot/
     assert_includes keys, p
   ensure
-    MiniTest::Spec::TYPES.replace original_types
+    Minitest::Spec::TYPES.replace original_types
   end
 
   def test_spec_type
-    original_types = MiniTest::Spec::TYPES.dup
+    original_types = Minitest::Spec::TYPES.dup
 
-    MiniTest::Spec.register_spec_type(/A$/, MiniSpecA)
-    MiniTest::Spec.register_spec_type MiniSpecB do |desc|
+    Minitest::Spec.register_spec_type(/A$/, MiniSpecA)
+    Minitest::Spec.register_spec_type MiniSpecB do |desc|
       desc.superclass == ExampleA
     end
 
-    assert_equal MiniSpecA, MiniTest::Spec.spec_type(ExampleA)
-    assert_equal MiniSpecB, MiniTest::Spec.spec_type(ExampleB)
+    assert_equal MiniSpecA, Minitest::Spec.spec_type(ExampleA)
+    assert_equal MiniSpecB, Minitest::Spec.spec_type(ExampleB)
   ensure
-    MiniTest::Spec::TYPES.replace original_types
+    Minitest::Spec::TYPES.replace original_types
   end
 
   def test_name
@@ -698,16 +699,13 @@ class TestMeta < MiniTest::Unit::TestCase
   def test_setup_teardown_behavior
     _, _, z, before_list, after_list = util_structure
 
-    @tu = MiniTest::Unit.new
-    MiniTest::Unit.runner = nil # protect the outer runner from the inner tests
+    @tu = z
 
-    with_output do
-      tc = z.new :test_0002_anonymous
-      tc.run @tu
-    end
+    run_tu_with_fresh_reporter
 
-    assert_equal [1, 2, 3], before_list
-    assert_equal [3, 2, 1], after_list
+    size = z.runnable_methods.size
+    assert_equal [1, 2, 3] * size, before_list
+    assert_equal [3, 2, 1] * size, after_list
   end
 
   def test_describe_first_structure
@@ -732,7 +730,7 @@ class TestMeta < MiniTest::Unit::TestCase
 
   def test_structure_subclasses
     z = nil
-    x = Class.new MiniTest::Spec do
+    x = Class.new Minitest::Spec do
       def xyz; end
     end
     y = Class.new x do
@@ -743,32 +741,19 @@ class TestMeta < MiniTest::Unit::TestCase
     assert_respond_to y.new(nil), "xyz"
     assert_respond_to z.new(nil), "xyz"
   end
-
-  def with_output # REFACTOR: dupe from metametameta
-    synchronize do
-      begin
-        @output = StringIO.new("")
-        MiniTest::Unit.output = @output
-
-        yield
-      ensure
-        MiniTest::Unit.output = STDOUT
-      end
-    end
-  end
 end
 
-require "minitest/metametameta"
-
 class TestSpecInTestCase < MetaMetaMetaTestCase
   def setup
     super
 
-    @tc = MiniTest::Unit::TestCase.new "fake tc"
+    @tc = self
     @assertion_count = 1
   end
 
-  def util_assert_triggered expected, klass = MiniTest::Assertion # REFACTOR
+  def assert_triggered expected, klass = Minitest::Assertion
+    @assertion_count += 1
+
     e = assert_raises klass do
       yield
     end
@@ -779,25 +764,23 @@ class TestSpecInTestCase < MetaMetaMetaTestCase
     assert_equal expected, msg
   end
 
-  def teardown # REFACTOR
-    assert_equal(@assertion_count, @tc._assertions,
-                 "expected #{@assertion_count} assertions to be fired during the test, not #{@tc._assertions}") if @tc.passed?
+  def teardown
+    msg = "expected #{@assertion_count} assertions, not #{@tc.assertions}"
+    assert_equal @assertion_count, @tc.assertions, msg
   end
 
   def test_expectation
-    @assertion_count = 2
-
     @tc.assert_equal true, 1.must_equal(1)
   end
 
   def test_expectation_triggered
-    util_assert_triggered "Expected: 2\n  Actual: 1" do
+    assert_triggered "Expected: 2\n  Actual: 1" do
       1.must_equal 2
     end
   end
 
   def test_expectation_with_a_message
-    util_assert_triggered "Expected: 2\n  Actual: 1" do
+    assert_triggered "Expected: 2\n  Actual: 1" do
       1.must_equal 2, ""
     end
   end

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,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_skip
-    Class.new MiniTest::Unit::TestCase do
+    @tu =
+    Class.new Minitest::Test do
       def test_something
         assert true
       end
@@ -463,16 +383,17 @@ class TestMiniTestRunner < MetaMetaMetaTestCase
     expected = clean <<-EOM
       S.
 
-      Finished tests in 0.00
+      Finished in 0.00
 
-      2 tests, 1 assertions, 0 failures, 0 errors, 1 skips
+      2 runs, 1 assertions, 0 failures, 0 errors, 1 skips
     EOM
 
     assert_report expected
   end
 
   def test_run_skip_verbose
-    Class.new MiniTest::Unit::TestCase do
+    @tu =
+    Class.new Minitest::Test do
       def test_something
         assert true
       end
@@ -487,31 +408,31 @@ class TestMiniTestRunner < MetaMetaMetaTestCase
       #<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.io.puts "Running #{self.name} tests"
         @@foo = 1
       end
 
@@ -528,9 +449,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 +479,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 +499,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 +520,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 +530,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 +549,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 +557,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 +571,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 +579,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 +602,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 +611,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 +625,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 +637,54 @@ class TestMiniTestUnitOrder < MetaMetaMetaTestCase
   end
 end
 
-class TestMiniTestUnitTestCase < MiniTest::Unit::TestCase
+class TestMinitestRunnable < Minitest::Test
+  def setup_dup 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_dup expected_ivars
+    new_tc = @tc.dup
+
+    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_dup
+    setup_dup Minitest::Runnable
+
+    assert_dup %w(@NAME @assertions @failures)
+  end
+end
+
+class TestMinitestTest < TestMinitestRunnable
+  def test_dup
+    setup_dup Minitest::Test do |tc|
+      tc.time = 3.14
+    end
+
+    assert_dup %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 +694,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
@@ -989,7 +954,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 +1145,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 +1157,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 +1179,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 +1202,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
@@ -1406,7 +1371,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 +1447,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 +1512,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 +1629,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 +1651,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 +1665,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 +1681,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 +1690,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 +1709,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 +1742,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
+    @tu = Class.new Minitest::Test, &block
 
-    MiniTest::Unit.runner = @tu
+    run_tu_with_fresh_reporter
 
-    Class.new MiniTest::Unit::TestCase, &block
-
-    with_output do
-      @tu.run
-    end
-
-    recorded = @tu.recording.fetch("test_method").map(&:class)
+    recorded = 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 +1764,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 +1780,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 +1803,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(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